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