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