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