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