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