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