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