````// Copyright 2009 The Go Authors. All rights reserved.`
`// Use of this source code is governed by a BSD-style`
`// license that can be found in the LICENSE file.`

`package strconv`

`import "math/bits"`

`const fastSmalls = true // enable fast path for small integers`

`// FormatUint returns the string representation of i in the given base,`
`// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'`
`// for digit values >= 10.`
`func FormatUint(i uint64, base int) string {`
`	if fastSmalls && i < nSmalls && base == 10 {`
`		return small(int(i))`
`	}`
`	_, s := formatBits(nil, i, base, false, false)`
`	return s`
`}`

`// FormatInt returns the string representation of i in the given base,`
`// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'`
`// for digit values >= 10.`
`func FormatInt(i int64, base int) string {`
`	if fastSmalls && 0 <= i && i < nSmalls && base == 10 {`
`		return small(int(i))`
`	}`
`	_, s := formatBits(nil, uint64(i), base, i < 0, false)`
`	return s`
`}`

`// Itoa is equivalent to FormatInt(int64(i), 10).`
`func Itoa(i int) string {`
`	return FormatInt(int64(i), 10)`
`}`

`// AppendInt appends the string form of the integer i,`
`// as generated by FormatInt, to dst and returns the extended buffer.`
`func AppendInt(dst []byte, i int64, base int) []byte {`
`	if fastSmalls && 0 <= i && i < nSmalls && base == 10 {`
`		return append(dst, small(int(i))...)`
`	}`
`	dst, _ = formatBits(dst, uint64(i), base, i < 0, true)`
`	return dst`
`}`

`// AppendUint appends the string form of the unsigned integer i,`
`// as generated by FormatUint, to dst and returns the extended buffer.`
`func AppendUint(dst []byte, i uint64, base int) []byte {`
`	if fastSmalls && i < nSmalls && base == 10 {`
`		return append(dst, small(int(i))...)`
`	}`
`	dst, _ = formatBits(dst, i, base, false, true)`
`	return dst`
`}`

`// small returns the string for an i with 0 <= i < nSmalls.`
`func small(i int) string {`
`	if i < 10 {`
`		return digits[i : i+1]`
`	}`
`	return smallsString[i*2 : i*2+2]`
`}`

`const nSmalls = 100`

`const smallsString = "00010203040506070809" +`
`	"10111213141516171819" +`
`	"20212223242526272829" +`
`	"30313233343536373839" +`
`	"40414243444546474849" +`
`	"50515253545556575859" +`
`	"60616263646566676869" +`
`	"70717273747576777879" +`
`	"80818283848586878889" +`
`	"90919293949596979899"`

`const host32bit = ^uint(0)>>32 == 0`

`const digits = "0123456789abcdefghijklmnopqrstuvwxyz"`

`// formatBits computes the string representation of u in the given base.`
`// If neg is set, u is treated as negative int64 value. If append_ is`
`// set, the string is appended to dst and the resulting byte slice is`
`// returned as the first result value; otherwise the string is returned`
`// as the second result value.`
`func formatBits(dst []byte, u uint64, base int, neg, append_ bool) (d []byte, s string) {`
`	if base < 2 || base > len(digits) {`
`		panic("strconv: illegal AppendInt/FormatInt base")`
`	}`
`	// 2 <= base && base <= len(digits)`

`	var a [64 + 1]byte // +1 for sign of 64bit value in base 2`
`	i := len(a)`

`	if neg {`
`		u = -u`
`	}`

`	// convert bits`
`	// We use uint values where we can because those will`
`	// fit into a single register even on a 32bit machine.`
`	if base == 10 {`
`		// common case: use constants for / because`
`		// the compiler can optimize it into a multiply+shift`

`		if host32bit {`
`			// convert the lower digits using 32bit operations`
`			for u >= 1e9 {`
`				// Avoid using r = a%b in addition to q = a/b`
`				// since 64bit division and modulo operations`
`				// are calculated by runtime functions on 32bit machines.`
`				q := u / 1e9`
`				us := uint(u - q*1e9) // u % 1e9 fits into a uint`
`				for j := 4; j > 0; j-- {`
`					is := us % 100 * 2`
`					us /= 100`
`					i -= 2`
`					a[i+1] = smallsString[is+1]`
`					a[i+0] = smallsString[is+0]`
`				}`

`				// us < 10, since it contains the last digit`
`				// from the initial 9-digit us.`
`				i--`
`				a[i] = smallsString[us*2+1]`

`				u = q`
`			}`
`			// u < 1e9`
`		}`

`		// u guaranteed to fit into a uint`
`		us := uint(u)`
`		for us >= 100 {`
`			is := us % 100 * 2`
`			us /= 100`
`			i -= 2`
`			a[i+1] = smallsString[is+1]`
`			a[i+0] = smallsString[is+0]`
`		}`

`		// us < 100`
`		is := us * 2`
`		i--`
`		a[i] = smallsString[is+1]`
`		if us >= 10 {`
`			i--`
`			a[i] = smallsString[is]`
`		}`

`	} else if isPowerOfTwo(base) {`
`		// Use shifts and masks instead of / and %.`
`		// Base is a power of 2 and 2 <= base <= len(digits) where len(digits) is 36.`
`		// The largest power of 2 below or equal to 36 is 32, which is 1 << 5;`
`		// i.e., the largest possible shift count is 5. By &-ind that value with`
`		// the constant 7 we tell the compiler that the shift count is always`
`		// less than 8 which is smaller than any register width. This allows`
`		// the compiler to generate better code for the shift operation.`
`		shift := uint(bits.TrailingZeros(uint(base))) & 7`
`		b := uint64(base)`
`		m := uint(base) - 1 // == 1<<shift - 1`
`		for u >= b {`
`			i--`
`			a[i] = digits[uint(u)&m]`
`			u >>= shift`
`		}`
`		// u < base`
`		i--`
`		a[i] = digits[uint(u)]`
`	} else {`
`		// general case`
`		b := uint64(base)`
`		for u >= b {`
`			i--`
`			// Avoid using r = a%b in addition to q = a/b`
`			// since 64bit division and modulo operations`
`			// are calculated by runtime functions on 32bit machines.`
`			q := u / b`
`			a[i] = digits[uint(u-q*b)]`
`			u = q`
`		}`
`		// u < base`
`		i--`
`		a[i] = digits[uint(u)]`
`	}`

`	// add sign, if any`
`	if neg {`
`		i--`
`		a[i] = '-'`
`	}`

`	if append_ {`
`		d = append(dst, a[i:]...)`
`		return`
`	}`
`	s = string(a[i:])`
`	return`
`}`

`func isPowerOfTwo(x int) bool {`
`	return x&(x-1) == 0`
`}`
```