1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

crate::ix!();

pub trait Init {

    /**
      | Initialize internal state from the
      | database and block index.
      |
      */
    fn init(&mut self) -> bool;
}

#[inline] pub fn readle16(ptr: *const u8) -> u16 {
    
    todo!();
        /*
            uint16_t x;
        memcpy((char*)&x, ptr, 2);
        return le16toh(x);
        */
}

#[inline] pub fn readle32(ptr: *const u8) -> u32 {
    
    todo!();
        /*
            uint32_t x;
        memcpy((char*)&x, ptr, 4);
        return le32toh(x);
        */
}

#[inline] pub fn readle64(ptr: *const u8) -> u64 {
    
    todo!();
        /*
            uint64_t x;
        memcpy((char*)&x, ptr, 8);
        return le64toh(x);
        */
}

#[inline] pub fn writele16(
        ptr: *mut u8,
        x:   u16)  {
    
    todo!();
        /*
            uint16_t v = htole16(x);
        memcpy(ptr, (char*)&v, 2);
        */
}

#[inline] pub fn writele32(
        ptr: *mut u8,
        x:   u32)  {
    
    todo!();
        /*
            uint32_t v = htole32(x);
        memcpy(ptr, (char*)&v, 4);
        */
}

#[inline] pub fn writele64(
        ptr: *mut u8,
        x:   u64)  {
    
    todo!();
        /*
            uint64_t v = htole64(x);
        memcpy(ptr, (char*)&v, 8);
        */
}

#[inline] pub fn readbe16(ptr: *const u8) -> u16 {
    
    todo!();
        /*
            uint16_t x;
        memcpy((char*)&x, ptr, 2);
        return be16toh(x);
        */
}

#[inline] pub fn readbe32(ptr: *const u8) -> u32 {
    
    todo!();
        /*
            uint32_t x;
        memcpy((char*)&x, ptr, 4);
        return be32toh(x);
        */
}

#[inline] pub fn readbe64(ptr: *const u8) -> u64 {
    
    todo!();
        /*
            uint64_t x;
        memcpy((char*)&x, ptr, 8);
        return be64toh(x);
        */
}

#[inline] pub fn writebe32(
        ptr: *mut u8,
        x:   u32)  {
    
    todo!();
        /*
            uint32_t v = htobe32(x);
        memcpy(ptr, (char*)&v, 4);
        */
}

#[inline] pub fn writebe64(
        ptr: *mut u8,
        x:   u64)  {
    
    todo!();
        /*
            uint64_t v = htobe64(x);
        memcpy(ptr, (char*)&v, 8);
        */
}

/**
  | Return the smallest number n such that
  | (x >> n) == 0 (or 64 if the highest bit in
  | x is set.
  |
  */
#[inline] pub fn count_bits(x: u64) -> u64 {
    
    todo!();
        /*
            #if HAVE_BUILTIN_CLZL
        if (sizeof(unsigned long) >= sizeof(uint64_t)) {
            return x ? 8 * sizeof(unsigned long) - __builtin_clzl(x) : 0;
        }
    #endif
    #if HAVE_BUILTIN_CLZLL
        if (sizeof(unsigned long long) >= sizeof(uint64_t)) {
            return x ? 8 * sizeof(unsigned long long) - __builtin_clzll(x) : 0;
        }
    #endif
        int ret = 0;
        while (x) {
            x >>= 1;
            ++ret;
        }
        return ret;
        */
}