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