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