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