func strconv.ParseUint

155 uses

	strconv (current package)
		atoi.go#L60: func ParseUint(s string, base int, bitSize int) (uint64, error) {
		atoi.go#L198: 	un, err = ParseUint(s, base, bitSize)

	database/sql
		convert.go#L446: 		u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())

	encoding/json
		decode.go#L796: 					n, err := strconv.ParseUint(s, 10, 64)
		decode.go#L1005: 			n, err := strconv.ParseUint(s, 10, 64)

	encoding/xml
		read.go#L633: 		utmp, err := strconv.ParseUint(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
		xml.go#L1057: 					n, err := strconv.ParseUint(s, base, 64)

	flag
		flag.go#L189: 	v, err := strconv.ParseUint(s, 0, strconv.IntSize)
		flag.go#L210: 	v, err := strconv.ParseUint(s, 0, 64)

	fmt
		scan.go#L687: 	i, err := strconv.ParseUint(tok, base, 64)

	github.com/andybalholm/cascadia
		parser.go#L35: 		v, _ := strconv.ParseUint(p.s[start:i], 16, 21)

	github.com/go-git/go-git/v5/config
		config.go#L296: 		winUint, err := strconv.ParseUint(window, 10, 32)

	github.com/go-git/go-git/v5/plumbing/filemode
		filemode.go#L59: 	n, err := strconv.ParseUint(s, 8, 32)

	github.com/go-redis/redis/v8
		command.go#L246: 		return strconv.ParseUint(val, 10, 64)
		command.go#L700: 	return strconv.ParseUint(cmd.Val(), 10, 64)

	github.com/go-redis/redis/v8/internal/util
		strconv.go#L14: 	return strconv.ParseUint(BytesToString(b), base, bitSize)

	github.com/golang-migrate/migrate/v4/database/postgres
		postgres.go#L196: 				if pos, err := strconv.ParseUint(pgErr.Position, 10, 64); err == nil {

	github.com/golang-migrate/migrate/v4/source
		parse.go#L27: 		versionUint64, err := strconv.ParseUint(m[1], 10, 64)

	github.com/golang/protobuf/proto
		properties.go#L154: 			n, _ := strconv.ParseUint(s, 10, 32)
		text_decode.go#L394: 			if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
		text_decode.go#L407: 			if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
		text_decode.go#L412: 		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
		text_decode.go#L416: 		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
		text_decode.go#L738: 		i, err := strconv.ParseUint(ss, 8, 8)
		text_decode.go#L758: 		i, err := strconv.ParseUint(ss, 16, 64)

	github.com/google/licensecheck
		license.go#L233: 			if n, err := strconv.ParseUint(f[5:len(f)-1], 0, 0); err == nil {

	github.com/google/pprof/profile
		legacy_java_profile.go#L261: 		addr, err := strconv.ParseUint(jloc[1], 16, 64)
		legacy_profile.go#L117: 			addr, err := strconv.ParseUint(stk, 0, 64)
		legacy_profile.go#L641: 		if addr, err := strconv.ParseUint(s, 0, 64); err == nil {
		legacy_profile.go#L1060: 	if mapping.Start, err = strconv.ParseUint(start, 16, 64); err != nil {
		legacy_profile.go#L1063: 	if mapping.Limit, err = strconv.ParseUint(end, 16, 64); err != nil {
		legacy_profile.go#L1067: 		if mapping.Offset, err = strconv.ParseUint(offset, 16, 64); err != nil {

	github.com/jackc/pgconn
		config.go#L657: 	port, err := strconv.ParseUint(s, 10, 16)

	github.com/jackc/pgtype
		oid.go#L26: 	n, err := strconv.ParseUint(string(src), 10, 32)
		pguint32.go#L81: 	n, err := strconv.ParseUint(string(src), 10, 32)
		tid.go#L77: 	blockNumber, err := strconv.ParseUint(parts[0], 10, 32)
		tid.go#L82: 	offsetNumber, err := strconv.ParseUint(parts[1], 10, 16)

	github.com/kevinburke/ssh_config
		validators.go#L75: 		_, err := strconv.ParseUint(val, 10, 64)

	github.com/prometheus/common/model
		fingerprinting.go#L27: 	num, err := strconv.ParseUint(s, 16, 64)
		fingerprinting.go#L33: 	num, err := strconv.ParseUint(s, 16, 64)

	github.com/prometheus/procfs
		cpuinfo.go#L80: 			v, err := strconv.ParseUint(field[1], 0, 32)
		cpuinfo.go#L108: 			v, err := strconv.ParseUint(field[1], 0, 32)
		cpuinfo.go#L116: 			v, err := strconv.ParseUint(field[1], 0, 32)
		cpuinfo.go#L130: 			v, err := strconv.ParseUint(field[1], 0, 32)
		cpuinfo.go#L148: 			v, err := strconv.ParseUint(field[1], 0, 32)
		cpuinfo.go#L154: 			v, err := strconv.ParseUint(field[1], 0, 32)
		ipvs.go#L102: 	stats.Connections, err = strconv.ParseUint(statFields[0], 16, 64)
		ipvs.go#L106: 	stats.IncomingPackets, err = strconv.ParseUint(statFields[1], 16, 64)
		ipvs.go#L110: 	stats.OutgoingPackets, err = strconv.ParseUint(statFields[2], 16, 64)
		ipvs.go#L114: 	stats.IncomingBytes, err = strconv.ParseUint(statFields[3], 16, 64)
		ipvs.go#L118: 	stats.OutgoingBytes, err = strconv.ParseUint(statFields[4], 16, 64)
		ipvs.go#L182: 			weight, err := strconv.ParseUint(fields[3], 10, 64)
		ipvs.go#L186: 			activeConn, err := strconv.ParseUint(fields[4], 10, 64)
		ipvs.go#L190: 			inactConn, err := strconv.ParseUint(fields[5], 10, 64)
		ipvs.go#L235: 	port, err := strconv.ParseUint(portString, 16, 16)
		meminfo.go#L171: 		v, err := strconv.ParseUint(fields[1], 0, 64)
		mountstats.go#L424: 		n, err := strconv.ParseUint(s, 10, 64)
		mountstats.go#L453: 		n, err := strconv.ParseUint(s, 10, 64)
		mountstats.go#L518: 			n, err := strconv.ParseUint(st, 10, 64)
		mountstats.go#L587: 		n, err := strconv.ParseUint(s, 10, 64)
		net_dev.go#L106: 	line.RxBytes, err = strconv.ParseUint(fields[0], 10, 64)
		net_dev.go#L110: 	line.RxPackets, err = strconv.ParseUint(fields[1], 10, 64)
		net_dev.go#L114: 	line.RxErrors, err = strconv.ParseUint(fields[2], 10, 64)
		net_dev.go#L118: 	line.RxDropped, err = strconv.ParseUint(fields[3], 10, 64)
		net_dev.go#L122: 	line.RxFIFO, err = strconv.ParseUint(fields[4], 10, 64)
		net_dev.go#L126: 	line.RxFrame, err = strconv.ParseUint(fields[5], 10, 64)
		net_dev.go#L130: 	line.RxCompressed, err = strconv.ParseUint(fields[6], 10, 64)
		net_dev.go#L134: 	line.RxMulticast, err = strconv.ParseUint(fields[7], 10, 64)
		net_dev.go#L140: 	line.TxBytes, err = strconv.ParseUint(fields[8], 10, 64)
		net_dev.go#L144: 	line.TxPackets, err = strconv.ParseUint(fields[9], 10, 64)
		net_dev.go#L148: 	line.TxErrors, err = strconv.ParseUint(fields[10], 10, 64)
		net_dev.go#L152: 	line.TxDropped, err = strconv.ParseUint(fields[11], 10, 64)
		net_dev.go#L156: 	line.TxFIFO, err = strconv.ParseUint(fields[12], 10, 64)
		net_dev.go#L160: 	line.TxCollisions, err = strconv.ParseUint(fields[13], 10, 64)
		net_dev.go#L164: 	line.TxCarrier, err = strconv.ParseUint(fields[14], 10, 64)
		net_dev.go#L168: 	line.TxCompressed, err = strconv.ParseUint(fields[15], 10, 64)
		net_softnet.go#L77: 	if processed, err = strconv.ParseUint(columns[0], 16, 32); err != nil {
		net_softnet.go#L80: 	if dropped, err = strconv.ParseUint(columns[1], 16, 32); err != nil {
		net_softnet.go#L83: 	if timeSqueezed, err = strconv.ParseUint(columns[2], 16, 32); err != nil {
		net_unix.go#L207: 	return strconv.ParseUint(hexStr, 16, 32)
		net_unix.go#L211: 	typ, err := strconv.ParseUint(hexStr, 16, 16)
		net_unix.go#L219: 	flags, err := strconv.ParseUint(hexStr, 16, 32)
		net_unix.go#L235: 	return strconv.ParseUint(inodeStr, 10, 64)
		proc_ns.go#L59: 		inode, err := strconv.ParseUint(strings.Trim(fields[1], "[]"), 10, 32)
		proc_status.go#L101: 		vKBytes, _ := strconv.ParseUint(v, 10, 64)
		schedstat.go#L76: 			cpu.RunningNanoseconds, err = strconv.ParseUint(match[8], 10, 64)
		schedstat.go#L81: 			cpu.WaitingNanoseconds, err = strconv.ParseUint(match[9], 10, 64)
		schedstat.go#L86: 			cpu.RunTimeslices, err = strconv.ParseUint(match[10], 10, 64)
		schedstat.go#L102: 		stats.RunningNanoseconds, err = strconv.ParseUint(match[1], 10, 64)
		schedstat.go#L107: 		stats.WaitingNanoseconds, err = strconv.ParseUint(match[2], 10, 64)
		schedstat.go#L112: 		stats.RunTimeslices, err = strconv.ParseUint(match[3], 10, 64)
		stat.go#L186: 			if stat.BootTime, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
		stat.go#L190: 			if stat.IRQTotal, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
		stat.go#L196: 				if stat.IRQ[i], err = strconv.ParseUint(count, 10, 64); err != nil {
		stat.go#L201: 			if stat.ContextSwitches, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
		stat.go#L205: 			if stat.ProcessCreated, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
		stat.go#L209: 			if stat.ProcessesRunning, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
		stat.go#L213: 			if stat.ProcessesBlocked, err = strconv.ParseUint(parts[1], 10, 64); err != nil {

	github.com/prometheus/procfs/internal/util
		parse.go#L26: 		u, err := strconv.ParseUint(s, 10, 32)
		parse.go#L41: 		u, err := strconv.ParseUint(s, 10, 64)
		parse.go#L73: 	return strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)
		valueparser.go#L79: 	v, err := strconv.ParseUint(vp.v, base, 64)

	github.com/yuin/goldmark/renderer/html
		html.go#L734: 							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 16, 32)
		html.go#L745: 							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 0, 32)

	github.com/yuin/goldmark/util
		util.go#L605: 							v, _ := strconv.ParseUint(BytesToReadOnlyString(source[start:i]), 16, 32)
		util.go#L617: 							v, _ := strconv.ParseUint(BytesToReadOnlyString(source[start:i]), 0, 32)

	go/scanner
		scanner.go#L294: 	n, err := strconv.ParseUint(string(text[i+1:]), 10, 0)

	golang.org/x/crypto/ssh
		tcpip.go#L346: 		port, err := strconv.ParseUint(portString, 10, 16)

	golang.org/x/net/http2
		server.go#L2040: 			if cl, err := strconv.ParseUint(vv[0], 10, 63); err == nil {
		server.go#L2427: 			if cl, err := strconv.ParseUint(clen, 10, 63); err == nil {
		transport.go#L2034: 			if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil {

	golang.org/x/pkgsite/internal/worker
		memory.go#L50: 		ki, err = strconv.ParseUint(words[1], 10, 64)
		memory.go#L148: 		u, err := strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)
		memory.go#L176: 		u, err := strconv.ParseUint(fs[1], 10, 64)

	golang.org/x/text/internal/language
		lookup.go#L205: 		if i, err := strconv.ParseUint(string(s), 10, 10); err == nil {

	google.golang.org/api/googleapi
		types.go#L61: 		v, err := strconv.ParseUint(s, 10, 64)
		types.go#L80: 		v, err := strconv.ParseUint(s, 10, 32)

	google.golang.org/api/transport/http/internal/propagation
		http.go#L63: 	sid, err := strconv.ParseUint(spanstr, 10, 64)
		http.go#L73: 	o, err := strconv.ParseUint(h[2:], 10, 64)

	google.golang.org/grpc/codes
		codes.go#L230: 	if ci, err := strconv.ParseUint(string(b), 10, 32); err == nil {

	google.golang.org/grpc/internal/binarylog
		env_config.go#L167: 			hdrLenStr, err = strconv.ParseUint(s, 10, 64)
		env_config.go#L179: 			msgLenStr, err = strconv.ParseUint(s, 10, 64)
		env_config.go#L194: 			hdrLenStr, err = strconv.ParseUint(s, 10, 64)
		env_config.go#L200: 			msgLenStr, err = strconv.ParseUint(s, 10, 64)

	google.golang.org/grpc/internal/transport
		http_util.go#L516: 			parsed, err := strconv.ParseUint(msg[i+1:i+3], 16, 8)

	google.golang.org/protobuf/encoding/protojson
		decode.go#L677: 		if n, err := strconv.ParseUint(name, base10, b32); err == nil {
		decode.go#L682: 		if n, err := strconv.ParseUint(name, base10, b64); err == nil {

	google.golang.org/protobuf/internal/encoding/defval
		default.go#L80: 		if v, err := strconv.ParseUint(s, 10, 32); err == nil {
		default.go#L84: 		if v, err := strconv.ParseUint(s, 10, 64); err == nil {

	google.golang.org/protobuf/internal/encoding/json
		decode_string.go#L58: 				v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
		decode_string.go#L69: 					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
		decode_token.go#L168: 	n, err := strconv.ParseUint(s, 10, bitSize)

	google.golang.org/protobuf/internal/encoding/tag
		tag.go#L44: 			n, _ := strconv.ParseUint(s, 10, 32)

	google.golang.org/protobuf/internal/encoding/text
		decode_string.go#L96: 				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
		decode_string.go#L107: 				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
		decode_string.go#L121: 				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
		decode_string.go#L132: 					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
		decode_token.go#L223: 		n, err := strconv.ParseUint(t.str, 0, 64)
		decode_token.go#L252: 	n, err := strconv.ParseUint(t.str, 0, 64)
		decode_token.go#L265: 	n, err := strconv.ParseUint(t.str, 0, 32)
		decode_token.go#L283: 		if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
		decode_token.go#L301: 		if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {

	google.golang.org/protobuf/internal/impl
		message.go#L170: 					n, _ := strconv.ParseUint(s, 10, 64)
		message.go#L198: 				n, _ := strconv.ParseUint(s, 10, 64)

	gopkg.in/yaml.v2
		resolve.go#L159: 			uintv, err := strconv.ParseUint(plain, 0, 64)
		resolve.go#L178: 				uintv, err := strconv.ParseUint(plain[2:], 2, 64)

	net/http
		h2_bundle.go#L5595: 			if cl, err := strconv.ParseUint(vv[0], 10, 63); err == nil {
		h2_bundle.go#L5982: 			if cl, err := strconv.ParseUint(clen, 10, 63); err == nil {
		h2_bundle.go#L8537: 			if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil {
		transfer.go#L1051: 	n, err := strconv.ParseUint(cl, 10, 63)

	net/http/httptest
		recorder.go#L229: 	n, err := strconv.ParseUint(cl, 10, 63)

	runtime/pprof
		proto.go#L640: 		lo, err := strconv.ParseUint(string(addr[:i]), 16, 64)
		proto.go#L644: 		hi, err := strconv.ParseUint(string(addr[i+1:]), 16, 64)
		proto.go#L653: 		offset, err := strconv.ParseUint(string(next()), 16, 64)

	text/template/parse
		node.go#L666: 	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.