package bits

Import Path
	math/bits (on go.dev)

Dependency Relation
	imports one package, and imported by 30 packages

Involved Source Files

	  d bits.go
		Package bits implements bit counting and manipulation
		functions for the predeclared unsigned integer types.
		
		Functions in this package may be implemented directly by
		the compiler, for better performance. For those functions
		the code in this package will not be used. Which
		functions are implemented by the compiler depends on the
		architecture and the Go release.

	    bits_errors.go
	    bits_tables.go
Code Examples

	Add32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 33<<32 + 12
			n1 := []uint32{33, 12}
			// Second number is 21<<32 + 23
			n2 := []uint32{21, 23}
			// Add them together without producing carry.
			d1, carry := bits.Add32(n1[1], n2[1], 0)
			d0, _ := bits.Add32(n1[0], n2[0], carry)
			nsum := []uint32{d0, d1}
			fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		
			// First number is 1<<32 + 2147483648
			n1 = []uint32{1, 0x80000000}
			// Second number is 1<<32 + 2147483648
			n2 = []uint32{1, 0x80000000}
			// Add them together producing carry.
			d1, carry = bits.Add32(n1[1], n2[1], 0)
			d0, _ = bits.Add32(n1[0], n2[0], carry)
			nsum = []uint32{d0, d1}
			fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		}

	Add64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 33<<64 + 12
			n1 := []uint64{33, 12}
			// Second number is 21<<64 + 23
			n2 := []uint64{21, 23}
			// Add them together without producing carry.
			d1, carry := bits.Add64(n1[1], n2[1], 0)
			d0, _ := bits.Add64(n1[0], n2[0], carry)
			nsum := []uint64{d0, d1}
			fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		
			// First number is 1<<64 + 9223372036854775808
			n1 = []uint64{1, 0x8000000000000000}
			// Second number is 1<<64 + 9223372036854775808
			n2 = []uint64{1, 0x8000000000000000}
			// Add them together producing carry.
			d1, carry = bits.Add64(n1[1], n2[1], 0)
			d0, _ = bits.Add64(n1[0], n2[0], carry)
			nsum = []uint64{d0, d1}
			fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		}

	Div32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 0<<32 + 6
			n1 := []uint32{0, 6}
			// Second number is 0<<32 + 3
			n2 := []uint32{0, 3}
			// Divide them together.
			quo, rem := bits.Div32(n1[0], n1[1], n2[1])
			nsum := []uint32{quo, rem}
			fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
		
			// First number is 2<<32 + 2147483648
			n1 = []uint32{2, 0x80000000}
			// Second number is 0<<32 + 2147483648
			n2 = []uint32{0, 0x80000000}
			// Divide them together.
			quo, rem = bits.Div32(n1[0], n1[1], n2[1])
			nsum = []uint32{quo, rem}
			fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
		}

	Div64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 0<<64 + 6
			n1 := []uint64{0, 6}
			// Second number is 0<<64 + 3
			n2 := []uint64{0, 3}
			// Divide them together.
			quo, rem := bits.Div64(n1[0], n1[1], n2[1])
			nsum := []uint64{quo, rem}
			fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
		
			// First number is 2<<64 + 9223372036854775808
			n1 = []uint64{2, 0x8000000000000000}
			// Second number is 0<<64 + 9223372036854775808
			n2 = []uint64{0, 0x8000000000000000}
			// Divide them together.
			quo, rem = bits.Div64(n1[0], n1[1], n2[1])
			nsum = []uint64{quo, rem}
			fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
		}

	LeadingZeros16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))
		}

	LeadingZeros32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
		}

	LeadingZeros64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
		}

	LeadingZeros8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
		}

	Len16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
		}

	Len32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
		}

	Len64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
		}

	Len8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
		}

	Mul32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 0<<32 + 12
			n1 := []uint32{0, 12}
			// Second number is 0<<32 + 12
			n2 := []uint32{0, 12}
			// Multiply them together without producing overflow.
			hi, lo := bits.Mul32(n1[1], n2[1])
			nsum := []uint32{hi, lo}
			fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
		
			// First number is 0<<32 + 2147483648
			n1 = []uint32{0, 0x80000000}
			// Second number is 0<<32 + 2
			n2 = []uint32{0, 2}
			// Multiply them together producing overflow.
			hi, lo = bits.Mul32(n1[1], n2[1])
			nsum = []uint32{hi, lo}
			fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
		}

	Mul64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 0<<64 + 12
			n1 := []uint64{0, 12}
			// Second number is 0<<64 + 12
			n2 := []uint64{0, 12}
			// Multiply them together without producing overflow.
			hi, lo := bits.Mul64(n1[1], n2[1])
			nsum := []uint64{hi, lo}
			fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
		
			// First number is 0<<64 + 9223372036854775808
			n1 = []uint64{0, 0x8000000000000000}
			// Second number is 0<<64 + 2
			n2 = []uint64{0, 2}
			// Multiply them together producing overflow.
			hi, lo = bits.Mul64(n1[1], n2[1])
			nsum = []uint64{hi, lo}
			fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
		}

	OnesCount
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("OnesCount(%b) = %d\n", 14, bits.OnesCount(14))
		}

	OnesCount16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
		}

	OnesCount32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
		}

	OnesCount64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
		}

	OnesCount8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
		}

	Reverse16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%016b\n", 19)
			fmt.Printf("%016b\n", bits.Reverse16(19))
		}

	Reverse32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%032b\n", 19)
			fmt.Printf("%032b\n", bits.Reverse32(19))
		}

	Reverse64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%064b\n", 19)
			fmt.Printf("%064b\n", bits.Reverse64(19))
		}

	Reverse8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%08b\n", 19)
			fmt.Printf("%08b\n", bits.Reverse8(19))
		}

	ReverseBytes16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%016b\n", 15)
			fmt.Printf("%016b\n", bits.ReverseBytes16(15))
		}

	ReverseBytes32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%032b\n", 15)
			fmt.Printf("%032b\n", bits.ReverseBytes32(15))
		}

	ReverseBytes64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%064b\n", 15)
			fmt.Printf("%064b\n", bits.ReverseBytes64(15))
		}

	RotateLeft16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%016b\n", 15)
			fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))
			fmt.Printf("%016b\n", bits.RotateLeft16(15, -2))
		}

	RotateLeft32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%032b\n", 15)
			fmt.Printf("%032b\n", bits.RotateLeft32(15, 2))
			fmt.Printf("%032b\n", bits.RotateLeft32(15, -2))
		}

	RotateLeft64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%064b\n", 15)
			fmt.Printf("%064b\n", bits.RotateLeft64(15, 2))
			fmt.Printf("%064b\n", bits.RotateLeft64(15, -2))
		}

	RotateLeft8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("%08b\n", 15)
			fmt.Printf("%08b\n", bits.RotateLeft8(15, 2))
			fmt.Printf("%08b\n", bits.RotateLeft8(15, -2))
		}

	Sub32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 33<<32 + 23
			n1 := []uint32{33, 23}
			// Second number is 21<<32 + 12
			n2 := []uint32{21, 12}
			// Sub them together without producing carry.
			d1, carry := bits.Sub32(n1[1], n2[1], 0)
			d0, _ := bits.Sub32(n1[0], n2[0], carry)
			nsum := []uint32{d0, d1}
			fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		
			// First number is 3<<32 + 2147483647
			n1 = []uint32{3, 0x7fffffff}
			// Second number is 1<<32 + 2147483648
			n2 = []uint32{1, 0x80000000}
			// Sub them together producing carry.
			d1, carry = bits.Sub32(n1[1], n2[1], 0)
			d0, _ = bits.Sub32(n1[0], n2[0], carry)
			nsum = []uint32{d0, d1}
			fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		}

	Sub64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			// First number is 33<<64 + 23
			n1 := []uint64{33, 23}
			// Second number is 21<<64 + 12
			n2 := []uint64{21, 12}
			// Sub them together without producing carry.
			d1, carry := bits.Sub64(n1[1], n2[1], 0)
			d0, _ := bits.Sub64(n1[0], n2[0], carry)
			nsum := []uint64{d0, d1}
			fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		
			// First number is 3<<64 + 9223372036854775807
			n1 = []uint64{3, 0x7fffffffffffffff}
			// Second number is 1<<64 + 9223372036854775808
			n2 = []uint64{1, 0x8000000000000000}
			// Sub them together producing carry.
			d1, carry = bits.Sub64(n1[1], n2[1], 0)
			d0, _ = bits.Sub64(n1[0], n2[0], carry)
			nsum = []uint64{d0, d1}
			fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
		}

	TrailingZeros16
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))
		}

	TrailingZeros32
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))
		}

	TrailingZeros64
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))
		}

	TrailingZeros8
		package main
		
		import (
			"fmt"
			"math/bits"
		)
		
		func main() {
			fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))
		}


Package-Level Functions (total 49)

	 func Add(x, y, carry uint) (sum, carryOut uint)
		Add returns the sum with carry of x, y and carry: sum = x + y + carry.
		The carry input must be 0 or 1; otherwise the behavior is undefined.
		The carryOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func Add32(x, y, carry uint32) (sum, carryOut uint32)
		Add32 returns the sum with carry of x, y and carry: sum = x + y + carry.
		The carry input must be 0 or 1; otherwise the behavior is undefined.
		The carryOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func Add64(x, y, carry uint64) (sum, carryOut uint64)
		Add64 returns the sum with carry of x, y and carry: sum = x + y + carry.
		The carry input must be 0 or 1; otherwise the behavior is undefined.
		The carryOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func Div(hi, lo, y uint) (quo, rem uint)
		Div returns the quotient and remainder of (hi, lo) divided by y:
		quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper
		half in parameter hi and the lower half in parameter lo.
		Div panics for y == 0 (division by zero) or y <= hi (quotient overflow).

	 func Div32(hi, lo, y uint32) (quo, rem uint32)
		Div32 returns the quotient and remainder of (hi, lo) divided by y:
		quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper
		half in parameter hi and the lower half in parameter lo.
		Div32 panics for y == 0 (division by zero) or y <= hi (quotient overflow).

	 func Div64(hi, lo, y uint64) (quo, rem uint64)
		Div64 returns the quotient and remainder of (hi, lo) divided by y:
		quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper
		half in parameter hi and the lower half in parameter lo.
		Div64 panics for y == 0 (division by zero) or y <= hi (quotient overflow).

	 func LeadingZeros(x uint) int
		LeadingZeros returns the number of leading zero bits in x; the result is [UintSize] for x == 0.

	 func LeadingZeros16(x uint16) int
		LeadingZeros16 returns the number of leading zero bits in x; the result is 16 for x == 0.

	 func LeadingZeros32(x uint32) int
		LeadingZeros32 returns the number of leading zero bits in x; the result is 32 for x == 0.

	 func LeadingZeros64(x uint64) int
		LeadingZeros64 returns the number of leading zero bits in x; the result is 64 for x == 0.

	 func LeadingZeros8(x uint8) int
		LeadingZeros8 returns the number of leading zero bits in x; the result is 8 for x == 0.

	 func Len(x uint) int
		Len returns the minimum number of bits required to represent x; the result is 0 for x == 0.

	 func Len16(x uint16) (n int)
		Len16 returns the minimum number of bits required to represent x; the result is 0 for x == 0.

	 func Len32(x uint32) (n int)
		Len32 returns the minimum number of bits required to represent x; the result is 0 for x == 0.

	 func Len64(x uint64) (n int)
		Len64 returns the minimum number of bits required to represent x; the result is 0 for x == 0.

	 func Len8(x uint8) int
		Len8 returns the minimum number of bits required to represent x; the result is 0 for x == 0.

	 func Mul(x, y uint) (hi, lo uint)
		Mul returns the full-width product of x and y: (hi, lo) = x * y
		with the product bits' upper half returned in hi and the lower
		half returned in lo.
		
		This function's execution time does not depend on the inputs.

	 func Mul32(x, y uint32) (hi, lo uint32)
		Mul32 returns the 64-bit product of x and y: (hi, lo) = x * y
		with the product bits' upper half returned in hi and the lower
		half returned in lo.
		
		This function's execution time does not depend on the inputs.

	 func Mul64(x, y uint64) (hi, lo uint64)
		Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
		with the product bits' upper half returned in hi and the lower
		half returned in lo.
		
		This function's execution time does not depend on the inputs.

	 func OnesCount(x uint) int
		OnesCount returns the number of one bits ("population count") in x.

	 func OnesCount16(x uint16) int
		OnesCount16 returns the number of one bits ("population count") in x.

	 func OnesCount32(x uint32) int
		OnesCount32 returns the number of one bits ("population count") in x.

	 func OnesCount64(x uint64) int
		OnesCount64 returns the number of one bits ("population count") in x.

	 func OnesCount8(x uint8) int
		OnesCount8 returns the number of one bits ("population count") in x.

	 func Rem(hi, lo, y uint) uint
		Rem returns the remainder of (hi, lo) divided by y. Rem panics for
		y == 0 (division by zero) but, unlike Div, it doesn't panic on a
		quotient overflow.

	 func Rem32(hi, lo, y uint32) uint32
		Rem32 returns the remainder of (hi, lo) divided by y. Rem32 panics
		for y == 0 (division by zero) but, unlike [Div32], it doesn't panic
		on a quotient overflow.

	 func Rem64(hi, lo, y uint64) uint64
		Rem64 returns the remainder of (hi, lo) divided by y. Rem64 panics
		for y == 0 (division by zero) but, unlike [Div64], it doesn't panic
		on a quotient overflow.

	 func Reverse(x uint) uint
		Reverse returns the value of x with its bits in reversed order.

	 func Reverse16(x uint16) uint16
		Reverse16 returns the value of x with its bits in reversed order.

	 func Reverse32(x uint32) uint32
		Reverse32 returns the value of x with its bits in reversed order.

	 func Reverse64(x uint64) uint64
		Reverse64 returns the value of x with its bits in reversed order.

	 func Reverse8(x uint8) uint8
		Reverse8 returns the value of x with its bits in reversed order.

	 func ReverseBytes(x uint) uint
		ReverseBytes returns the value of x with its bytes in reversed order.
		
		This function's execution time does not depend on the inputs.

	 func ReverseBytes16(x uint16) uint16
		ReverseBytes16 returns the value of x with its bytes in reversed order.
		
		This function's execution time does not depend on the inputs.

	 func ReverseBytes32(x uint32) uint32
		ReverseBytes32 returns the value of x with its bytes in reversed order.
		
		This function's execution time does not depend on the inputs.

	 func ReverseBytes64(x uint64) uint64
		ReverseBytes64 returns the value of x with its bytes in reversed order.
		
		This function's execution time does not depend on the inputs.

	 func RotateLeft(x uint, k int) uint
		RotateLeft returns the value of x rotated left by (k mod [UintSize]) bits.
		To rotate x right by k bits, call RotateLeft(x, -k).
		
		This function's execution time does not depend on the inputs.

	 func RotateLeft16(x uint16, k int) uint16
		RotateLeft16 returns the value of x rotated left by (k mod 16) bits.
		To rotate x right by k bits, call RotateLeft16(x, -k).
		
		This function's execution time does not depend on the inputs.

	 func RotateLeft32(x uint32, k int) uint32
		RotateLeft32 returns the value of x rotated left by (k mod 32) bits.
		To rotate x right by k bits, call RotateLeft32(x, -k).
		
		This function's execution time does not depend on the inputs.

	 func RotateLeft64(x uint64, k int) uint64
		RotateLeft64 returns the value of x rotated left by (k mod 64) bits.
		To rotate x right by k bits, call RotateLeft64(x, -k).
		
		This function's execution time does not depend on the inputs.

	 func RotateLeft8(x uint8, k int) uint8
		RotateLeft8 returns the value of x rotated left by (k mod 8) bits.
		To rotate x right by k bits, call RotateLeft8(x, -k).
		
		This function's execution time does not depend on the inputs.

	 func Sub(x, y, borrow uint) (diff, borrowOut uint)
		Sub returns the difference of x, y and borrow: diff = x - y - borrow.
		The borrow input must be 0 or 1; otherwise the behavior is undefined.
		The borrowOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func Sub32(x, y, borrow uint32) (diff, borrowOut uint32)
		Sub32 returns the difference of x, y and borrow, diff = x - y - borrow.
		The borrow input must be 0 or 1; otherwise the behavior is undefined.
		The borrowOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func Sub64(x, y, borrow uint64) (diff, borrowOut uint64)
		Sub64 returns the difference of x, y and borrow: diff = x - y - borrow.
		The borrow input must be 0 or 1; otherwise the behavior is undefined.
		The borrowOut output is guaranteed to be 0 or 1.
		
		This function's execution time does not depend on the inputs.

	 func TrailingZeros(x uint) int
		TrailingZeros returns the number of trailing zero bits in x; the result is [UintSize] for x == 0.

	 func TrailingZeros16(x uint16) int
		TrailingZeros16 returns the number of trailing zero bits in x; the result is 16 for x == 0.

	 func TrailingZeros32(x uint32) int
		TrailingZeros32 returns the number of trailing zero bits in x; the result is 32 for x == 0.

	 func TrailingZeros64(x uint64) int
		TrailingZeros64 returns the number of trailing zero bits in x; the result is 64 for x == 0.

	 func TrailingZeros8(x uint8) int
		TrailingZeros8 returns the number of trailing zero bits in x; the result is 8 for x == 0.


Package-Level Constants (only one)

	const UintSize = 64
		UintSize is the size of a uint in bits.

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.