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