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