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