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