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