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