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