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