}

func le64(p []byte) uint64 {
	return uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 | uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
}

func le32(p []byte) uint32 {
	return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
}

func decodeVarint(data []byte) (uint64, []byte, error) {
	var i int
	var u uint64
	for i = 0; ; i++ {

}

func le64(p []byte) uint64 {
	return uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 | uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
}

func le32(p []byte) uint32 {
	return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
}

func decodeVarint(data []byte) (uint64, []byte, error) {
	var u uint64
	for i := 0; ; i++ {

		slr := NewReader(b, i == 0)
		g32 := slr.ReadUint32()
		if g32 != e32 {
			t.Fatalf("slr.ReadUint32() got %d want %d", g32, e32)
		}
		g64 := slr.ReadUint64()
		if g64 != e64 {
			t.Fatalf("slr.ReadUint64() got %d want %d", g64, e64)
		}
		g32 = uint32(slr.ReadULEB128())
		if g32 != e32 {
			t.Fatalf("slr.ReadULEB128() got %d want %d", g32, e32)
		}
		g64 = slr.ReadULEB128()
		if g64 != e64 {

			t.Errorf("Len64(1<<%d) = %d, want %d", i, got, want)
		}
	}
}

func TestBitLen32(t *testing.T) {
	for i := 0; i <= 32; i++ {
		got := bits.Len32(1 << i)
		want := i + 1
		if want == 33 {
			want = 0
		}
		if got != want {
			t.Errorf("Len32(1<<%d) = %d, want %d", i, got, want)
		}
	}
}

func TestBitLen16(t *testing.T) {
	for i := 0; i <= 16; i++ {
		got := bits.Len16(1 << i)
		want := i + 1

		len1 = len(scope.podMap)
		lenHints1 = len(scope.podTopologyHints)
		err := scope.RemoveContainer(tc.containerID)
		len2 = len(scope.podMap)
		lenHints2 = len(scope.podTopologyHints)
		if err != nil {
			t.Errorf("Expected error to be nil but got: %v", err)
		}
		if len1-len2 != 1 {
			t.Errorf("Remove Pod from podMap resulted in error")
		}
		if lenHints1-lenHints2 != 1 {

}

func ExampleLen16() {
	fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
	// Output:
	// Len16(0000000000001000) = 4
}

func ExampleLen32() {
	fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
	// Output:
	// Len32(00000000000000000000000000001000) = 4
}

func ExampleLen64() {
	fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
	// Output:

			!read(&oh32.NumberOfRvaAndSizes) {
			return nil, fmt.Errorf("failure to read PE32 optional header: %v", err)
		}

		dd, err := readDataDirectories(r, sz-uint16(oh32MinSz), oh32.NumberOfRvaAndSizes)
		if err != nil {
			return nil, err
		}

		copy(oh32.DataDirectory[:], dd)

		return &oh32, nil
	case 0x20b: // PE32+
		var (
			oh64 OptionalHeader64

    }

    @Override
    public int compareTo(RelativePath o) {
        int len1 = segments.length;
        int len2 = o.segments.length;

        if (len1 != len2) {
            return len1 - len2;
        }

        int lim = Math.min(len1, len2);
        String[] v1 = segments;
        String[] v2 = o.segments;

        int k = 0;
        while (k < lim) {

	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	;;
freebsd_386)
	mkerrors="$mkerrors -m32"
	mksyscall="./mksyscall.pl -l32"
	mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl"
	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	;;
freebsd_amd64)
	mkerrors="$mkerrors -m64"

//     struct nfgenmsg (definition: https://github.com/torvalds/linux/blob/v6.7/include/uapi/linux/netfilter/nfnetlink.h#L32-L38)
//   - attributes [variable-sized, must align to 4 bytes from the start of attribute]
//     struct nlattr (definition: https://github.com/torvalds/linux/blob/v6.7/include/uapi/linux/netlink.h#L220-L232)
//
// Attribute Components:
//   - length [2 bytes]