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