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