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