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