func strconv.ParseInt

126 uses

	strconv (current package)
		atoi.go#L179: func ParseInt(s string, base int, bitSize int) (i int64, err error) {
		atoi.go#L254: 	i64, err := ParseInt(s, 10, 0)

	cloud.google.com/go/storage
		reader.go#L190: 				gen64, err := strconv.ParseInt(res.Header.Get("X-Goog-Generation"), 10, 64)
		reader.go#L219: 		size, err = strconv.ParseInt(cr[strings.LastIndex(cr, "/")+1:], 10, 64)
		reader.go#L226: 			startOffset, err = strconv.ParseInt(cr[len("bytes="):dashIndex], 10, 64)
		reader.go#L256: 		metaGen, err = strconv.ParseInt(res.Header.Get("X-Goog-Metageneration"), 10, 64)

	database/sql
		convert.go#L434: 		i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())

	encoding/asn1
		common.go#L126: 			i, err := strconv.ParseInt(part[8:], 10, 64)

	encoding/json
		decode.go#L200: 	return strconv.ParseInt(string(n), 10, 64)
		decode.go#L788: 					n, err := strconv.ParseInt(s, 10, 64)
		decode.go#L997: 			n, err := strconv.ParseInt(s, 10, 64)

	encoding/xml
		read.go#L623: 		itmp, err := strconv.ParseInt(strings.TrimSpace(string(src)), 10, dst.Type().Bits())

	flag
		flag.go#L147: 	v, err := strconv.ParseInt(s, 0, strconv.IntSize)
		flag.go#L168: 	v, err := strconv.ParseInt(s, 0, 64)

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

	github.com/aws/aws-sdk-go/aws/awsutil
		path_value.go#L48: 				i, _ := strconv.ParseInt(m[2], 10, 32)

	github.com/aws/aws-sdk-go/aws/corehandlers
		handlers.go#L35: 		length, _ = strconv.ParseInt(slength, 10, 64)
		handlers.go#L144: 			code, _ := strconv.ParseInt(s[1], 10, 64)

	github.com/aws/aws-sdk-go/aws/ec2metadata
		service.go#L196: 		i, err := strconv.ParseInt(v, 10, 64)

	github.com/aws/aws-sdk-go/internal/ini
		literal_tokens.go#L174: 		v.integer, err = strconv.ParseInt(string(raw), base, 64)

	github.com/aws/aws-sdk-go/private/protocol/rest
		unmarshal.go#L221: 		i, err := strconv.ParseInt(header, 10, 64)

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		unmarshal.go#L273: 		v, err := strconv.ParseInt(node.Text, 10, 64)

	github.com/evanw/esbuild/internal/js_lexer
		js_lexer.go#L2007: 					if value, err := strconv.ParseInt(number, base, 32); err == nil {

	github.com/evanw/esbuild/pkg/api
		serve_other.go#L519: 		if port, err := strconv.ParseInt(text, 10, 32); err == nil {

	github.com/go-git/go-git/v5/plumbing/format/index
		decoder.go#L452: 	stage, err := strconv.ParseInt(string(ascii), 8, 64)

	github.com/go-git/go-git/v5/plumbing/format/objfile
		reader.go#L58: 	size, err = strconv.ParseInt(string(raw), 10, 64)

	github.com/go-git/go-git/v5/plumbing/object
		object.go#L130: 	ts, err := strconv.ParseInt(string(b[:space]), 10, 64)
		object.go#L142: 	tzhours, err1 := strconv.ParseInt(timezone[0:3], 10, 64)
		object.go#L143: 	tzmins, err2 := strconv.ParseInt(timezone[3:], 10, 64)

	github.com/go-git/go-git/v5/plumbing/protocol/packp
		ulreq_decode.go#L229: 	secs, d.err = strconv.ParseInt(string(d.line), 10, 64)

	github.com/go-redis/redis/v8
		command.go#L231: 		return strconv.ParseInt(val, 10, 64)
		command.go#L693: 	return strconv.ParseInt(cmd.Val(), 10, 64)
		command.go#L1462: 			grp.Consumers, err = strconv.ParseInt(val, 0, 64)
		command.go#L1464: 			grp.Pending, err = strconv.ParseInt(val, 0, 64)

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

	github.com/golang/protobuf/proto
		text_decode.go#L386: 		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
		text_decode.go#L399: 		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
		text_decode.go#L448: 		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {

	github.com/google/pprof/profile
		legacy_java_profile.go#L144: 				if p.Period, err = strconv.ParseInt(value, 0, 64); err != nil {
		legacy_java_profile.go#L148: 				millis, err := strconv.ParseInt(value, 0, 64)
		legacy_java_profile.go#L205: 			if s.Value[0], err = strconv.ParseInt(value1, 0, 64); err != nil {
		legacy_java_profile.go#L208: 			if s.Value[1], err = strconv.ParseInt(value2, 0, 64); err != nil {
		legacy_java_profile.go#L276: 			if n, err := strconv.ParseInt(fileLine[3], 10, 64); err == nil && n > 0 {
		legacy_profile.go#L110: 		n, err := strconv.ParseInt(m[1], 0, 64)
		legacy_profile.go#L563: 		if period, err = strconv.ParseInt(header[6], 10, 64); err != nil {
		legacy_profile.go#L594: 		count, err := strconv.ParseInt(countString, 10, 64)
		legacy_profile.go#L598: 		size, err := strconv.ParseInt(sizeString, 10, 64)
		legacy_profile.go#L724: 			if cpuHz, err = strconv.ParseInt(val, 0, 64); err != nil {
		legacy_profile.go#L728: 			if p.Period, err = strconv.ParseInt(val, 0, 64); err != nil {
		legacy_profile.go#L732: 			ms, err := strconv.ParseInt(val, 0, 64)
		legacy_profile.go#L806: 	v1, err := strconv.ParseInt(sampleData[1], 10, 64)
		legacy_profile.go#L810: 	v2, err := strconv.ParseInt(sampleData[2], 10, 64)

	github.com/jackc/pgconn
		config.go#L222: 	minReadBufferSize, err := strconv.ParseInt(settings["min_read_buffer_size"], 10, 32)
		config.go#L688: 	timeout, err := strconv.ParseInt(s, 10, 64)

	github.com/jackc/pgproto3/v2
		error_response.go#L69: 			n, _ := strconv.ParseInt(s, 10, 32)
		error_response.go#L73: 			n, _ := strconv.ParseInt(s, 10, 32)
		error_response.go#L93: 			n, _ := strconv.ParseInt(s, 10, 32)

	github.com/jackc/pgtype
		array.go#L312: 			n, err := strconv.ParseInt(s.String(), 10, 32)
		int2.go#L83: 		num, err := strconv.ParseInt(value, 10, 16)
		int2.go#L207: 	n, err := strconv.ParseInt(string(src), 10, 16)
		int4.go#L75: 		num, err := strconv.ParseInt(value, 10, 32)
		int4.go#L199: 	n, err := strconv.ParseInt(string(src), 10, 32)
		int8.go#L66: 		num, err := strconv.ParseInt(value, 10, 64)
		int8.go#L190: 	n, err := strconv.ParseInt(string(src), 10, 64)
		interval.go#L100: 		scalar, err := strconv.ParseInt(parts[i], 10, 64)
		interval.go#L127: 		hours, err := strconv.ParseInt(timeParts[0], 10, 64)
		interval.go#L132: 		minutes, err := strconv.ParseInt(timeParts[1], 10, 64)
		interval.go#L139: 		seconds, err := strconv.ParseInt(secondParts[0], 10, 64)
		interval.go#L146: 			uSeconds, err = strconv.ParseInt(secondParts[1], 10, 64)
		qchar.go#L99: 		num, err := strconv.ParseInt(value, 10, 8)
		time.go#L118: 	hours, err := strconv.ParseInt(s[0:2], 10, 64)
		time.go#L124: 	minutes, err := strconv.ParseInt(s[3:5], 10, 64)
		time.go#L130: 	seconds, err := strconv.ParseInt(s[6:8], 10, 64)
		time.go#L138: 		n, err := strconv.ParseInt(fraction, 10, 64)

	github.com/jackc/pgx/v4
		conn.go#L141: 		n, err := strconv.ParseInt(s, 10, 32)

	github.com/lib/pq
		array.go#L453: 			if b[i], err = strconv.ParseInt(string(v), 10, 64); err != nil {
		conn.go#L339: 		seconds, err := strconv.ParseInt(timeout, 10, 0)
		conn.go#L1358: 	n, err := strconv.ParseInt(*affectedRows, 10, 64)
		encode.go#L114: 		i, err := strconv.ParseInt(string(s), 10, 64)
		encode.go#L536: 				r, err := strconv.ParseInt(string(s[1:4]), 8, 9)

	github.com/prometheus/common/expfmt
		text_parse.go#L464: 	timestamp, err := strconv.ParseInt(p.currentToken.String(), 10, 64)

	github.com/prometheus/common/model
		time.go#L128: 		v, err := strconv.ParseInt(string(p[0]), 10, 64)
		time.go#L135: 		v, err := strconv.ParseInt(string(p[0]), 10, 64)
		time.go#L148: 		va, err := strconv.ParseInt(p[1], 10, 32)

	github.com/prometheus/procfs
		mdstat.go#L149: 	size, err = strconv.ParseInt(sizeStr, 10, 64)
		mdstat.go#L169: 	total, err = strconv.ParseInt(matches[2], 10, 64)
		mdstat.go#L174: 	active, err = strconv.ParseInt(matches[3], 10, 64)
		mdstat.go#L188: 	syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)
		net_unix.go#L227: 	st, err := strconv.ParseInt(hexStr, 16, 8)
		proc.go#L113: 		pid, err := strconv.ParseInt(n, 10, 64)
		proc.go#L186: 		fd, err := strconv.ParseInt(n, 10, 32)
		proc_limits.go#L152: 	i, err := strconv.ParseInt(s, 10, 64)
		stat.go#L117: 	cpuID, err := strconv.ParseInt(cpu[3:], 10, 64)

	github.com/prometheus/procfs/internal/util
		parse.go#L56: 		u, err := strconv.ParseInt(s, 10, 64)
		valueparser.go#L60: 	v, err := strconv.ParseInt(vp.v, base, 64)

	github.com/sergi/go-diff/diffmatchpatch
		diff.go#L1314: 			n, err := strconv.ParseInt(param, 10, 0)

	golang.org/x/oauth2
		token.go#L109: 		if i, err := strconv.ParseInt(s, 10, 64); err == nil {

	google.golang.org/api/googleapi
		types.go#L23: 		v, err := strconv.ParseInt(s, 10, 64)
		types.go#L42: 		v, err := strconv.ParseInt(s, 10, 32)

	google.golang.org/api/internal/third_party/uritemplates
		uritemplates.go#L185: 		parsed, err = strconv.ParseInt(split[1], 10, 0)

	google.golang.org/grpc
		service_config.go#L199: 		i, err := strconv.ParseInt(ss[0], 10, 32)
		service_config.go#L210: 		f, err := strconv.ParseInt(ss[1], 10, 64)

	google.golang.org/grpc/internal/transport
		http_util.go#L431: 	t, err := strconv.ParseInt(s[:size-1], 10, 64)

	google.golang.org/protobuf/encoding/protojson
		decode.go#L667: 		if n, err := strconv.ParseInt(name, base10, b32); err == nil {
		decode.go#L672: 		if n, err := strconv.ParseInt(name, base10, b64); err == nil {
		well_known_types.go#L731: 		secs, err = strconv.ParseInt(string(intp), 10, 64)
		well_known_types.go#L742: 			nanos, err = strconv.ParseInt(string(nanob), 10, 32)

	google.golang.org/protobuf/internal/encoding/defval
		default.go#L59: 			if n, err := strconv.ParseInt(s, 10, 32); err == nil {
		default.go#L72: 		if v, err := strconv.ParseInt(s, 10, 32); err == nil {
		default.go#L76: 		if v, err := strconv.ParseInt(s, 10, 64); err == nil {

	google.golang.org/protobuf/internal/encoding/json
		decode_number.go#L192: 		i, err := strconv.ParseInt(string(n.exp), 10, 32)
		decode_token.go#L150: 	n, err := strconv.ParseInt(s, 10, bitSize)

	google.golang.org/protobuf/internal/encoding/text
		decode.go#L417: 			if _, err := strconv.ParseInt(string(d.in[:num.size]), 10, 32); err == nil {
		decode_token.go#L190: 	num, _ := strconv.ParseInt(string(t.raw), 10, 32)
		decode_token.go#L277: 	if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
		decode_token.go#L295: 	if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {

	gopkg.in/yaml.v2
		resolve.go#L151: 			intv, err := strconv.ParseInt(plain, 0, 64)
		resolve.go#L170: 				intv, err := strconv.ParseInt(plain[2:], 2, 64)
		resolve.go#L183: 				intv, err := strconv.ParseInt("-" + plain[3:], 2, 64)

	math/big
		ratconv.go#L284: 		exp, err = strconv.ParseInt(string(digits), 10, 64)

	net/http
		fs.go#L899: 			i, err := strconv.ParseInt(end, 10, 64)
		fs.go#L909: 			i, err := strconv.ParseInt(start, 10, 64)
		fs.go#L924: 				i, err := strconv.ParseInt(end, 10, 64)
		server.go#L1155: 		v, err := strconv.ParseInt(cl, 10, 64)

	testing
		benchmark.go#L52: 		n, err := strconv.ParseInt(s[:len(s)-1], 10, 0)

	text/template/parse
		node.go#L671: 	i, err := strconv.ParseInt(text, 0, 64)