iodine 0.7.23 → 0.7.24
Sign up to get free protection for your applications and to get access to all the features.
Potentially problematic release.
This version of iodine might be problematic. Click here for more details.
- checksums.yaml +4 -4
- data/CHANGELOG.md +10 -0
- data/README.md +22 -1
- data/ext/iodine/extconf.rb +22 -7
- data/ext/iodine/fio.c +239 -292
- data/ext/iodine/fio.h +9 -0
- data/ext/iodine/hpack.h +1775 -0
- data/lib/iodine/version.rb +1 -1
- metadata +4 -3
data/ext/iodine/fio.h
CHANGED
|
@@ -4634,6 +4634,7 @@ static FIO_ARY_TYPE const FIO_NAME(s___const_invalid_object);
|
|
|
4634
4634
|
|
|
4635
4635
|
/** object copy required? */
|
|
4636
4636
|
#ifndef FIO_ARY_COPY
|
|
4637
|
+
#define FIO_ARY_COPY_IS_SIMPLE 1
|
|
4637
4638
|
#define FIO_ARY_COPY(dest, obj) ((dest) = (obj))
|
|
4638
4639
|
#endif
|
|
4639
4640
|
|
|
@@ -4930,14 +4931,21 @@ FIO_FUNC inline FIO_ARY_TYPE *FIO_NAME(to_a)(FIO_NAME(s) * ary) {
|
|
|
4930
4931
|
* The `src` Array remain untouched.
|
|
4931
4932
|
*/
|
|
4932
4933
|
FIO_FUNC inline void FIO_NAME(concat)(FIO_NAME(s) * dest, FIO_NAME(s) * src) {
|
|
4934
|
+
if (!src)
|
|
4935
|
+
return;
|
|
4933
4936
|
const size_t added = FIO_NAME(count)(src);
|
|
4934
4937
|
if (!added || !dest)
|
|
4935
4938
|
return;
|
|
4936
4939
|
FIO_NAME(__require_on_top)(dest, added);
|
|
4940
|
+
#if FIO_ARY_COPY_IS_SIMPLE
|
|
4941
|
+
memcpy(dest->arry + dest->end, src->arry + src->start,
|
|
4942
|
+
added * sizeof(*dest->arry));
|
|
4943
|
+
#else
|
|
4937
4944
|
/* don't use memcpy, in case copying has side-effects (see macro) */
|
|
4938
4945
|
for (size_t i = 0; i < added; ++i) {
|
|
4939
4946
|
FIO_ARY_COPY(((dest->arry + dest->end)[i]), ((src->arry + src->start)[i]));
|
|
4940
4947
|
}
|
|
4948
|
+
#endif
|
|
4941
4949
|
dest->end += added;
|
|
4942
4950
|
}
|
|
4943
4951
|
|
|
@@ -5341,6 +5349,7 @@ Done
|
|
|
5341
5349
|
#undef FIO_ARY_INVALID
|
|
5342
5350
|
#undef FIO_ARY_COMPARE
|
|
5343
5351
|
#undef FIO_ARY_COPY
|
|
5352
|
+
#undef FIO_ARY_COPY_IS_SIMPLE
|
|
5344
5353
|
#undef FIO_ARY_DESTROY
|
|
5345
5354
|
#undef FIO_ARY_REALLOC
|
|
5346
5355
|
#undef FIO_ARY_DEALLOC
|
data/ext/iodine/hpack.h
ADDED
|
@@ -0,0 +1,1775 @@
|
|
|
1
|
+
#ifndef H_HPACK_H
|
|
2
|
+
|
|
3
|
+
#ifndef _GNU_SOURCE
|
|
4
|
+
#define _GNU_SOURCE
|
|
5
|
+
#endif
|
|
6
|
+
|
|
7
|
+
#include <stdint.h>
|
|
8
|
+
#include <stdlib.h>
|
|
9
|
+
#include <string.h>
|
|
10
|
+
|
|
11
|
+
#include <fio.h>
|
|
12
|
+
|
|
13
|
+
#ifndef MAYBE_UNUSED
|
|
14
|
+
#define MAYBE_UNUSED __attribute__((unused))
|
|
15
|
+
#endif
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* Sets the limit for both a single header value and a packed header group.
|
|
19
|
+
* Must be less than 2^16 -1
|
|
20
|
+
*/
|
|
21
|
+
#define HPACK_BUFFER_SIZE 16384
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Sets the limit for the amount of data an HPACK dynamic table can reference.
|
|
25
|
+
* Should be less then 65,535 (2^16 -1 is the type size limit).
|
|
26
|
+
*/
|
|
27
|
+
#define HPACK_MAX_TABLE_SIZE 65535
|
|
28
|
+
|
|
29
|
+
/* *****************************************************************************
|
|
30
|
+
Types
|
|
31
|
+
***************************************************************************** */
|
|
32
|
+
|
|
33
|
+
/** A Short String (SString) struct, up to 65,535 bytes long */
|
|
34
|
+
typedef struct sstring_s {
|
|
35
|
+
uint16_t len;
|
|
36
|
+
uint8_t data[];
|
|
37
|
+
} sstring_s;
|
|
38
|
+
|
|
39
|
+
/** An HTTP/2 Header */
|
|
40
|
+
typedef struct http2_header_s {
|
|
41
|
+
sstring_s *name;
|
|
42
|
+
sstring_s *value;
|
|
43
|
+
} http2_header_s;
|
|
44
|
+
|
|
45
|
+
/** An HTTP/2 Header Collection */
|
|
46
|
+
typedef struct http2_header_array_s {
|
|
47
|
+
size_t len;
|
|
48
|
+
http2_header_s headers[];
|
|
49
|
+
} http2_header_array_s;
|
|
50
|
+
|
|
51
|
+
/** The HPACK context. */
|
|
52
|
+
typedef struct hpack_context_s hpack_context_s;
|
|
53
|
+
|
|
54
|
+
/* *****************************************************************************
|
|
55
|
+
API
|
|
56
|
+
***************************************************************************** */
|
|
57
|
+
|
|
58
|
+
/**
|
|
59
|
+
* Encodes an integer.
|
|
60
|
+
*
|
|
61
|
+
* Returns the number of bytes written to the destination buffer. If the buffer
|
|
62
|
+
* was too small, returns the number of bytes that would have been written.
|
|
63
|
+
*/
|
|
64
|
+
static inline int hpack_int_pack(void *dest, size_t limit, uint64_t i,
|
|
65
|
+
uint8_t prefix);
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* Decodes an integer, updating the `pos` marker to the next unprocessed byte.
|
|
69
|
+
*
|
|
70
|
+
* The position marker may start as non-zero, meaning that `len - (*pos)` is the
|
|
71
|
+
* actual length.
|
|
72
|
+
*
|
|
73
|
+
* An encoding / decoding error results in a return value of -1.
|
|
74
|
+
*/
|
|
75
|
+
static inline int64_t hpack_int_unpack(void *data, size_t len, uint8_t prefix,
|
|
76
|
+
size_t *pos);
|
|
77
|
+
|
|
78
|
+
/**
|
|
79
|
+
* Encodes a String.
|
|
80
|
+
*
|
|
81
|
+
* Returns the number of bytes written to the destination buffer. If the buffer
|
|
82
|
+
* was too small, returns the number of bytes that would have been written.
|
|
83
|
+
*/
|
|
84
|
+
static inline int hpack_string_pack(void *dest, size_t limit, void *data,
|
|
85
|
+
size_t len, uint8_t compress);
|
|
86
|
+
|
|
87
|
+
/**
|
|
88
|
+
* Decodes a String.
|
|
89
|
+
*
|
|
90
|
+
* Returns the number of bytes written to the destination buffer. If the buffer
|
|
91
|
+
* was too small, returns the number of bytes that would have been written.
|
|
92
|
+
*
|
|
93
|
+
* An encoding / decoding error results in a return value of -1.
|
|
94
|
+
*
|
|
95
|
+
* The position marker may start as non-zero, meaning that `len - (*pos)` is the
|
|
96
|
+
* actual length.
|
|
97
|
+
*/
|
|
98
|
+
static inline int hpack_string_unpack(void *dest, size_t limit, void *encoded,
|
|
99
|
+
size_t len, size_t *pos);
|
|
100
|
+
|
|
101
|
+
/* *****************************************************************************
|
|
102
|
+
Integer encoding
|
|
103
|
+
***************************************************************************** */
|
|
104
|
+
|
|
105
|
+
static inline int hpack_int_pack(void *dest_, size_t limit, uint64_t i,
|
|
106
|
+
uint8_t prefix) {
|
|
107
|
+
uint8_t mask = ((1 << (prefix)) - 1);
|
|
108
|
+
uint8_t *dest = (uint8_t *)dest_;
|
|
109
|
+
int len = 1;
|
|
110
|
+
|
|
111
|
+
if (!dest_ || !limit)
|
|
112
|
+
goto calc_final_length;
|
|
113
|
+
|
|
114
|
+
if (i < mask) {
|
|
115
|
+
// zero out prefix bits
|
|
116
|
+
dest[0] &= ~mask;
|
|
117
|
+
// fill in i;
|
|
118
|
+
dest[0] |= i;
|
|
119
|
+
return 1;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
dest[0] |= mask;
|
|
123
|
+
|
|
124
|
+
if ((size_t)len >= limit)
|
|
125
|
+
goto calc_final_length;
|
|
126
|
+
|
|
127
|
+
i -= mask;
|
|
128
|
+
|
|
129
|
+
while (i > 127) {
|
|
130
|
+
dest[len] = 128 | (i & 127);
|
|
131
|
+
++len;
|
|
132
|
+
if ((size_t)len >= limit)
|
|
133
|
+
goto calc_final_length;
|
|
134
|
+
i >>= 7;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
dest[len] = i & 0x7fU;
|
|
138
|
+
++len;
|
|
139
|
+
|
|
140
|
+
return len;
|
|
141
|
+
|
|
142
|
+
calc_final_length:
|
|
143
|
+
len = 1;
|
|
144
|
+
if (i < mask)
|
|
145
|
+
return len;
|
|
146
|
+
i -= mask;
|
|
147
|
+
while (i) {
|
|
148
|
+
++len;
|
|
149
|
+
i >>= 7;
|
|
150
|
+
}
|
|
151
|
+
return len;
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
static inline int64_t hpack_int_unpack(void *data_, size_t len, uint8_t prefix,
|
|
155
|
+
size_t *pos) {
|
|
156
|
+
uint8_t *data = (uint8_t *)data_;
|
|
157
|
+
len -= *pos;
|
|
158
|
+
if (len > 8)
|
|
159
|
+
len = 8;
|
|
160
|
+
uint64_t result = 0;
|
|
161
|
+
uint64_t bit = 0;
|
|
162
|
+
uint8_t mask = ((1 << (prefix)) - 1);
|
|
163
|
+
|
|
164
|
+
if ((mask & (data[*pos])) != mask) {
|
|
165
|
+
result = (mask & (data[(*pos)++]));
|
|
166
|
+
return (int64_t)result;
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
++(*pos);
|
|
170
|
+
--len;
|
|
171
|
+
|
|
172
|
+
while (len && (data[*pos] & 128)) {
|
|
173
|
+
result |= ((data[*pos] & 0x7fU) << (bit));
|
|
174
|
+
bit += 7;
|
|
175
|
+
++(*pos);
|
|
176
|
+
--len;
|
|
177
|
+
}
|
|
178
|
+
if (!len) {
|
|
179
|
+
return -1;
|
|
180
|
+
}
|
|
181
|
+
result |= ((data[*pos] & 0x7fU) << bit);
|
|
182
|
+
result += mask;
|
|
183
|
+
|
|
184
|
+
++(*pos);
|
|
185
|
+
return (int64_t)result;
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
/* *****************************************************************************
|
|
189
|
+
Huffman (internal API)
|
|
190
|
+
***************************************************************************** */
|
|
191
|
+
|
|
192
|
+
/* the huffman encoding map */
|
|
193
|
+
typedef const struct {
|
|
194
|
+
const uint32_t code;
|
|
195
|
+
const uint8_t bits;
|
|
196
|
+
} huffman_encode_s;
|
|
197
|
+
static const huffman_encode_s huffman_encode_table[];
|
|
198
|
+
|
|
199
|
+
/* the huffman decoding binary tree type */
|
|
200
|
+
typedef struct {
|
|
201
|
+
const int16_t value; // value, -1 == none.
|
|
202
|
+
const uint8_t offset[2]; // offset for 0 and one. 0 == leaf node.
|
|
203
|
+
} huffman_decode_s;
|
|
204
|
+
static const huffman_decode_s huffman_decode_tree[];
|
|
205
|
+
|
|
206
|
+
/**
|
|
207
|
+
* Unpack (de-compress) using HPACK huffman - returns the number of bytes
|
|
208
|
+
* written and advances the position marker.
|
|
209
|
+
*/
|
|
210
|
+
static MAYBE_UNUSED int hpack_huffman_unpack(void *dest, size_t limit,
|
|
211
|
+
void *encoded, size_t len,
|
|
212
|
+
size_t *pos);
|
|
213
|
+
|
|
214
|
+
/**
|
|
215
|
+
* Pack (compress) using HPACK huffman - returns the number of bytes written or
|
|
216
|
+
* required.
|
|
217
|
+
*/
|
|
218
|
+
static MAYBE_UNUSED int hpack_huffman_pack(void *dest, const int limit,
|
|
219
|
+
void *data, size_t len);
|
|
220
|
+
|
|
221
|
+
/* *****************************************************************************
|
|
222
|
+
String encoding
|
|
223
|
+
***************************************************************************** */
|
|
224
|
+
|
|
225
|
+
static MAYBE_UNUSED int hpack_string_pack(void *dest_, size_t limit,
|
|
226
|
+
void *data_, size_t len,
|
|
227
|
+
uint8_t compress) {
|
|
228
|
+
uint8_t *dest = (uint8_t *)dest_;
|
|
229
|
+
uint8_t *buf = (uint8_t *)data_;
|
|
230
|
+
int encoded_int_len = 0;
|
|
231
|
+
int pos = 0;
|
|
232
|
+
if (compress) {
|
|
233
|
+
dest[pos] = 128;
|
|
234
|
+
int comp_len = hpack_huffman_pack(NULL, 0, buf, len);
|
|
235
|
+
encoded_int_len = hpack_int_pack(dest, limit, comp_len, 7);
|
|
236
|
+
if (encoded_int_len + comp_len > (int)limit)
|
|
237
|
+
return comp_len + encoded_int_len;
|
|
238
|
+
comp_len = hpack_huffman_pack(dest + encoded_int_len,
|
|
239
|
+
limit - encoded_int_len, buf, len);
|
|
240
|
+
return encoded_int_len + comp_len;
|
|
241
|
+
}
|
|
242
|
+
dest[pos] = 0;
|
|
243
|
+
encoded_int_len = hpack_int_pack(dest, limit, len, 7);
|
|
244
|
+
if (encoded_int_len + (int)len > (int)limit)
|
|
245
|
+
return len + encoded_int_len;
|
|
246
|
+
memcpy(dest + encoded_int_len, buf, len);
|
|
247
|
+
return len + encoded_int_len;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
static MAYBE_UNUSED int hpack_string_unpack(void *dest_, size_t limit,
|
|
251
|
+
void *encoded_, size_t len,
|
|
252
|
+
size_t *pos) {
|
|
253
|
+
uint8_t *dest = (uint8_t *)dest_;
|
|
254
|
+
uint8_t *buf = (uint8_t *)encoded_;
|
|
255
|
+
const size_t org_pos = *pos;
|
|
256
|
+
uint8_t compressed = buf[*pos] & 128;
|
|
257
|
+
int64_t l = hpack_int_unpack(buf, len, 7, pos);
|
|
258
|
+
if (!l) {
|
|
259
|
+
return 0;
|
|
260
|
+
}
|
|
261
|
+
if (l == -1 || l > (int64_t)len - (int64_t)*pos) {
|
|
262
|
+
return -1;
|
|
263
|
+
}
|
|
264
|
+
len = l;
|
|
265
|
+
if (compressed) {
|
|
266
|
+
len = hpack_huffman_unpack(dest, limit, buf, len + (*pos), pos);
|
|
267
|
+
if (len > limit)
|
|
268
|
+
goto overflow;
|
|
269
|
+
} else {
|
|
270
|
+
if (len > limit)
|
|
271
|
+
goto overflow;
|
|
272
|
+
memcpy(dest, buf + (*pos), len);
|
|
273
|
+
*pos += len;
|
|
274
|
+
}
|
|
275
|
+
return len;
|
|
276
|
+
|
|
277
|
+
overflow:
|
|
278
|
+
*pos = org_pos;
|
|
279
|
+
return len;
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
/* *****************************************************************************
|
|
283
|
+
Huffman encoding
|
|
284
|
+
***************************************************************************** */
|
|
285
|
+
|
|
286
|
+
static MAYBE_UNUSED int hpack_huffman_unpack(void *dest_, size_t limit,
|
|
287
|
+
void *encoded_, size_t len,
|
|
288
|
+
size_t *r_pos) {
|
|
289
|
+
uint8_t *dest = (uint8_t *)dest_;
|
|
290
|
+
uint8_t *encoded = (uint8_t *)encoded_;
|
|
291
|
+
size_t pos = 0;
|
|
292
|
+
uint8_t expect = 0;
|
|
293
|
+
len -= *r_pos;
|
|
294
|
+
register const huffman_decode_s *node = huffman_decode_tree;
|
|
295
|
+
while (len) {
|
|
296
|
+
register const uint8_t byte = encoded[(*r_pos)++];
|
|
297
|
+
--len;
|
|
298
|
+
expect = 1;
|
|
299
|
+
for (uint8_t bit = 0; bit < 8; ++bit) {
|
|
300
|
+
node += node->offset[(byte >> (7 - bit)) & 1];
|
|
301
|
+
if (node->offset[0])
|
|
302
|
+
continue;
|
|
303
|
+
switch (node->value) {
|
|
304
|
+
case 256U:
|
|
305
|
+
goto done;
|
|
306
|
+
case -1:
|
|
307
|
+
goto error;
|
|
308
|
+
}
|
|
309
|
+
if (pos < limit)
|
|
310
|
+
dest[pos] = (uint8_t)node->value;
|
|
311
|
+
++pos;
|
|
312
|
+
/* test if all remaining bits are set (possible padding) */
|
|
313
|
+
expect = ((uint8_t)(byte | (0xFF << (7 - bit))) & 0xFF) ^ 0xFF;
|
|
314
|
+
node = huffman_decode_tree;
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
done:
|
|
318
|
+
if (expect) {
|
|
319
|
+
/* padding error */
|
|
320
|
+
return -1;
|
|
321
|
+
}
|
|
322
|
+
return pos;
|
|
323
|
+
error:
|
|
324
|
+
return -1;
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
static MAYBE_UNUSED int hpack_huffman_pack(void *dest_, const int limit,
|
|
328
|
+
void *data_, size_t len) {
|
|
329
|
+
uint8_t *dest = (uint8_t *)dest_;
|
|
330
|
+
uint8_t *data = (uint8_t *)data_;
|
|
331
|
+
int comp_len = 0;
|
|
332
|
+
uint8_t *pos = data;
|
|
333
|
+
const uint8_t *end = pos + len;
|
|
334
|
+
uint8_t offset = 0;
|
|
335
|
+
if (!len)
|
|
336
|
+
return 0;
|
|
337
|
+
if (!limit)
|
|
338
|
+
goto calc_final_length;
|
|
339
|
+
|
|
340
|
+
dest[comp_len] = 0;
|
|
341
|
+
do {
|
|
342
|
+
uint32_t code = huffman_encode_table[*pos].code;
|
|
343
|
+
uint8_t bits = huffman_encode_table[*pos].bits;
|
|
344
|
+
++pos;
|
|
345
|
+
|
|
346
|
+
if (offset) {
|
|
347
|
+
/* does the code fit in the existing byte */
|
|
348
|
+
if (bits + offset <= 8) {
|
|
349
|
+
dest[comp_len] |= code >> (24 + offset);
|
|
350
|
+
offset = offset + bits;
|
|
351
|
+
continue;
|
|
352
|
+
}
|
|
353
|
+
/* fill in current byte */
|
|
354
|
+
dest[comp_len] |= (code >> (24 + offset)) & 0xFF;
|
|
355
|
+
code <<= 8 - offset;
|
|
356
|
+
bits -= 8 - offset;
|
|
357
|
+
offset = 0;
|
|
358
|
+
++comp_len;
|
|
359
|
+
dest[comp_len] = 0;
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
/* make sure we have enough space */
|
|
363
|
+
if (((bits + (comp_len << 3) + 7) >> 3) >= limit)
|
|
364
|
+
goto calc_final_length;
|
|
365
|
+
|
|
366
|
+
/* copy full bytes */
|
|
367
|
+
switch (bits >> 3) {
|
|
368
|
+
case 3:
|
|
369
|
+
dest[comp_len + 2] = (uint8_t)(code >> 8) & 0xFF;
|
|
370
|
+
/* overflow */
|
|
371
|
+
case 2:
|
|
372
|
+
dest[comp_len + 1] = (uint8_t)(code >> 16) & 0xFF;
|
|
373
|
+
/* overflow */
|
|
374
|
+
case 1: /* overflow */
|
|
375
|
+
dest[comp_len + 0] = (uint8_t)(code >> 24) & 0xFF;
|
|
376
|
+
comp_len += (bits >> 3);
|
|
377
|
+
code <<= (bits & (~7));
|
|
378
|
+
dest[comp_len] = 0;
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
/* copy partial bits */
|
|
382
|
+
dest[comp_len] |= (uint8_t)(code >> 24) & ((uint8_t)0xFF);
|
|
383
|
+
offset = bits & 7;
|
|
384
|
+
} while (pos < end);
|
|
385
|
+
|
|
386
|
+
if (offset & 7) {
|
|
387
|
+
/* pad last bits as 1 */
|
|
388
|
+
dest[comp_len] |= (uint8_t)(0xFFUL >> (offset & 7));
|
|
389
|
+
++comp_len;
|
|
390
|
+
}
|
|
391
|
+
return comp_len;
|
|
392
|
+
|
|
393
|
+
calc_final_length:
|
|
394
|
+
|
|
395
|
+
comp_len = 0;
|
|
396
|
+
for (size_t i = 0; i < len; i++) {
|
|
397
|
+
comp_len += huffman_encode_table[data[i]].bits;
|
|
398
|
+
}
|
|
399
|
+
comp_len += 7;
|
|
400
|
+
comp_len >>= 3;
|
|
401
|
+
return comp_len;
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
/* *****************************************************************************
|
|
405
|
+
|
|
406
|
+
|
|
407
|
+
Testing
|
|
408
|
+
|
|
409
|
+
|
|
410
|
+
***************************************************************************** */
|
|
411
|
+
|
|
412
|
+
#if DEBUG
|
|
413
|
+
|
|
414
|
+
#include <inttypes.h>
|
|
415
|
+
#include <stdio.h>
|
|
416
|
+
|
|
417
|
+
void hpack_test(void) {
|
|
418
|
+
uint8_t buffer[1 << 15];
|
|
419
|
+
const size_t limit = (1 << 15);
|
|
420
|
+
size_t buf_pos = 0;
|
|
421
|
+
{
|
|
422
|
+
/* test integer packing */
|
|
423
|
+
int64_t result;
|
|
424
|
+
size_t pos = 0;
|
|
425
|
+
fprintf(stderr, "* HPACK testing integer primitive packing.\n");
|
|
426
|
+
if ((result = hpack_int_unpack((uint8_t *)"\x0c", 1, 4, &pos)) != 12) {
|
|
427
|
+
fprintf(stderr,
|
|
428
|
+
"* HPACK INTEGER DECODER ERROR ex. 0c 12 != %" PRId64 "\n",
|
|
429
|
+
result);
|
|
430
|
+
exit(-1);
|
|
431
|
+
}
|
|
432
|
+
|
|
433
|
+
pos = 0;
|
|
434
|
+
if ((result = hpack_int_unpack((uint8_t *)"\x1f\x9a\x0a", 3, 5, &pos)) !=
|
|
435
|
+
1337) {
|
|
436
|
+
fprintf(
|
|
437
|
+
stderr,
|
|
438
|
+
"* HPACK INTEGER DECODER ERROR ex. \\x1f\\x9a\\x0a 1337 != %" PRId64
|
|
439
|
+
"\n",
|
|
440
|
+
result);
|
|
441
|
+
exit(-1);
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
for (size_t i = 0; i < (1 << 21); ++i) {
|
|
445
|
+
buf_pos = 0;
|
|
446
|
+
int pack_bytes =
|
|
447
|
+
hpack_int_pack(buffer + buf_pos, limit - buf_pos, i, i & 7);
|
|
448
|
+
if (pack_bytes == -1) {
|
|
449
|
+
fprintf(stderr,
|
|
450
|
+
"* HPACK INTEGER ENCODE ERROR 1 ( %zu) (prefix == %zu)\n", i,
|
|
451
|
+
i & 7);
|
|
452
|
+
exit(-1);
|
|
453
|
+
}
|
|
454
|
+
buf_pos += pack_bytes;
|
|
455
|
+
pack_bytes =
|
|
456
|
+
hpack_int_pack(buffer + buf_pos, limit - buf_pos, (i << 4), i & 7);
|
|
457
|
+
if (pack_bytes == -1) {
|
|
458
|
+
fprintf(stderr,
|
|
459
|
+
"* HPACK INTEGER ENCODE ERROR 1 ( %zu) (prefix == %zu)\n", i,
|
|
460
|
+
i & 7);
|
|
461
|
+
exit(-1);
|
|
462
|
+
}
|
|
463
|
+
buf_pos = 0;
|
|
464
|
+
result = hpack_int_unpack(buffer, limit, (i & 7), &buf_pos);
|
|
465
|
+
if ((size_t)result != i) {
|
|
466
|
+
fprintf(stderr,
|
|
467
|
+
"* HPACK INTEGER DECODE ERROR 2 expected %zu got %" PRId64
|
|
468
|
+
" (prefix == %zu)\n",
|
|
469
|
+
i, result, (i & 7));
|
|
470
|
+
exit(-1);
|
|
471
|
+
}
|
|
472
|
+
result = hpack_int_unpack(buffer, limit, (i & 7), &buf_pos);
|
|
473
|
+
if ((size_t)result != (i << 4)) {
|
|
474
|
+
fprintf(stderr,
|
|
475
|
+
"* HPACK INTEGER DECODE ERROR 2 expected %zu got %" PRId64
|
|
476
|
+
" (prefix == %zu)\n",
|
|
477
|
+
(i << 4), result, (i & 7));
|
|
478
|
+
exit(-1);
|
|
479
|
+
}
|
|
480
|
+
}
|
|
481
|
+
fprintf(stderr, "* HPACK integer primitive test complete.\n");
|
|
482
|
+
}
|
|
483
|
+
buf_pos = 0;
|
|
484
|
+
{
|
|
485
|
+
/* validate huffman tree */
|
|
486
|
+
for (int i = 0; i < 257; ++i) {
|
|
487
|
+
const huffman_decode_s *node = huffman_decode_tree;
|
|
488
|
+
uint32_t code = huffman_encode_table[i].code;
|
|
489
|
+
uint8_t consumed = 32 - huffman_encode_table[i].bits;
|
|
490
|
+
while (consumed < 32) {
|
|
491
|
+
node += node->offset[(code >> 31) & 1];
|
|
492
|
+
code <<= 1;
|
|
493
|
+
++consumed;
|
|
494
|
+
}
|
|
495
|
+
if (i != node->value) {
|
|
496
|
+
fprintf(stderr,
|
|
497
|
+
"ERROR validating huffman tree - validation error for %d "
|
|
498
|
+
"(value: %d != "
|
|
499
|
+
"%d)\n",
|
|
500
|
+
i, node->value, i);
|
|
501
|
+
exit(-1);
|
|
502
|
+
}
|
|
503
|
+
}
|
|
504
|
+
fprintf(stderr, "* HPACK Huffman tree validated.\n");
|
|
505
|
+
/* test huffman encoding / decoding packing */
|
|
506
|
+
const size_t results_limit = 1024;
|
|
507
|
+
uint8_t results[1024];
|
|
508
|
+
size_t pos = 0;
|
|
509
|
+
memset(results, 0, results_limit);
|
|
510
|
+
int tmp = hpack_huffman_unpack(
|
|
511
|
+
results, results_limit,
|
|
512
|
+
"\x9d\x29\xad\x17\x18\x63\xc7\x8f\x0b\x97\xc8\xe9\xae\x82"
|
|
513
|
+
"\xae\x43\xd3",
|
|
514
|
+
17, &pos);
|
|
515
|
+
if (tmp == -1) {
|
|
516
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST FAILED unpacking error (1).\n");
|
|
517
|
+
exit(-1);
|
|
518
|
+
} else if ((size_t)tmp > (limit - buf_pos)) {
|
|
519
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST buffer full error (1).\n");
|
|
520
|
+
} else if (memcmp(results, "https://www.example.com", 23) || tmp != 23) {
|
|
521
|
+
fprintf(stderr,
|
|
522
|
+
"* HPACK HUFFMAN TEST FAILED result error (1).\n(%d) %.*s\n", tmp,
|
|
523
|
+
tmp, results);
|
|
524
|
+
exit(-1);
|
|
525
|
+
}
|
|
526
|
+
memset(results, 0, results_limit);
|
|
527
|
+
pos = 0;
|
|
528
|
+
tmp = hpack_huffman_unpack(
|
|
529
|
+
results, results_limit,
|
|
530
|
+
"\xf1\xe3\xc2\xe5\xf2\x3a\x6b\xa0\xab\x90\xf4\xff", 12, &pos);
|
|
531
|
+
if (tmp == -1) {
|
|
532
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST FAILED unpacking error (2).\n");
|
|
533
|
+
exit(-1);
|
|
534
|
+
} else if ((size_t)tmp > results_limit) {
|
|
535
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST buffer full error (2).\n");
|
|
536
|
+
} else if (memcmp(results, "www.example.com", 15) || tmp != 15) {
|
|
537
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST FAILED result error (2).\n");
|
|
538
|
+
exit(-1);
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
memset(results, 0, results_limit);
|
|
542
|
+
tmp = hpack_huffman_pack(results, results_limit, "https://www.example.com",
|
|
543
|
+
23);
|
|
544
|
+
if (tmp == -1) {
|
|
545
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST FAILED packing error!.\n");
|
|
546
|
+
exit(-1);
|
|
547
|
+
} else if ((size_t)tmp > limit - buf_pos) {
|
|
548
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST packing buffer full!\n");
|
|
549
|
+
} else if (tmp != 17 || memcmp("\x9d\x29\xad\x17\x18\x63\xc7\x8f\x0b\x97"
|
|
550
|
+
"\xc8\xe9\xae\x82\xae\x43\xd3",
|
|
551
|
+
results, 17)) {
|
|
552
|
+
fprintf(stderr,
|
|
553
|
+
"* HPACK HUFFMAN TEST FAILED packing result error!\n(%d) ", tmp);
|
|
554
|
+
for (int i = 0; i < tmp; ++i) {
|
|
555
|
+
fprintf(stderr, "\\x%.2X", results[i]);
|
|
556
|
+
}
|
|
557
|
+
fprintf(stderr, "\n");
|
|
558
|
+
exit(-1);
|
|
559
|
+
}
|
|
560
|
+
memset(results, 0, results_limit);
|
|
561
|
+
memset(buffer, 0, 128);
|
|
562
|
+
tmp = hpack_huffman_pack(
|
|
563
|
+
buffer, limit,
|
|
564
|
+
"I want to go home... but I have to write tests... woohoo!", 57);
|
|
565
|
+
if (tmp == -1) {
|
|
566
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST FAILED packing error (3).\n");
|
|
567
|
+
exit(-1);
|
|
568
|
+
} else if ((size_t)tmp > limit) {
|
|
569
|
+
fprintf(stderr, "* HPACK HUFFMAN TEST buffer full (3).\n");
|
|
570
|
+
} else {
|
|
571
|
+
int old_tmp = tmp;
|
|
572
|
+
pos = 0;
|
|
573
|
+
tmp = hpack_huffman_unpack(results, results_limit, buffer, tmp, &pos);
|
|
574
|
+
if (tmp == -1) {
|
|
575
|
+
fprintf(
|
|
576
|
+
stderr,
|
|
577
|
+
"* HPACK HUFFMAN TEST FAILED unpacking error (3) for %d bytes.\n"
|
|
578
|
+
"* Got (%d): %.*s\n",
|
|
579
|
+
old_tmp, tmp, (int)tmp, results);
|
|
580
|
+
exit(-1);
|
|
581
|
+
} else if (memcmp(results,
|
|
582
|
+
"I want to go home... but I have to write tests... "
|
|
583
|
+
"woohoo!",
|
|
584
|
+
57) ||
|
|
585
|
+
tmp != 57) {
|
|
586
|
+
fprintf(stderr,
|
|
587
|
+
"* HPACK HUFFMAN TEST FAILED result error (3).\n* Got "
|
|
588
|
+
"(%u): %.*s\n",
|
|
589
|
+
tmp, (int)tmp, results);
|
|
590
|
+
exit(-1);
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
fprintf(stderr, "* HPACK Huffman compression test finished.\n");
|
|
594
|
+
}
|
|
595
|
+
buf_pos = 0;
|
|
596
|
+
memset(buffer, 0, 128);
|
|
597
|
+
if (1) {
|
|
598
|
+
/* test string packing */
|
|
599
|
+
size_t pos = 0;
|
|
600
|
+
int tmp = hpack_string_unpack(
|
|
601
|
+
buffer, limit, "\x0a\x63\x75\x73\x74\x6f\x6d\x2d\x6b\x65\x79", 11,
|
|
602
|
+
&pos);
|
|
603
|
+
if (pos != 11) {
|
|
604
|
+
fprintf(stderr,
|
|
605
|
+
"* HPACK STRING UNPACKING FAILED(!) wrong reading position %zu "
|
|
606
|
+
"!= 11\n",
|
|
607
|
+
pos);
|
|
608
|
+
exit(-1);
|
|
609
|
+
}
|
|
610
|
+
if (tmp == -1) {
|
|
611
|
+
fprintf(stderr, "* HPACK STRING UNPACKING FAILED(!) for example.\n");
|
|
612
|
+
exit(-1);
|
|
613
|
+
} else {
|
|
614
|
+
if (tmp != 10)
|
|
615
|
+
fprintf(stderr,
|
|
616
|
+
"* HPACK STRING UNPACKING ERROR example len %d != 10.\n", tmp);
|
|
617
|
+
if (memcmp(buffer, "\x63\x75\x73\x74\x6f\x6d\x2d\x6b\x65\x79", 10))
|
|
618
|
+
fprintf(stderr,
|
|
619
|
+
"* HPACK STRING UNPACKING ERROR example returned: %.*s\n",
|
|
620
|
+
(int)tmp, buffer);
|
|
621
|
+
}
|
|
622
|
+
|
|
623
|
+
pos = 0;
|
|
624
|
+
memset(buffer, 0, 128);
|
|
625
|
+
tmp = hpack_string_unpack(
|
|
626
|
+
buffer, limit, "\x8c\xf1\xe3\xc2\xe5\xf2\x3a\x6b\xa0\xab\x90\xf4\xff",
|
|
627
|
+
13, &pos);
|
|
628
|
+
if (tmp == -1) {
|
|
629
|
+
fprintf(stderr,
|
|
630
|
+
"* HPACK STRING UNPACKING FAILED(!) for compressed example. %s\n",
|
|
631
|
+
buffer);
|
|
632
|
+
exit(-1);
|
|
633
|
+
} else {
|
|
634
|
+
if (tmp != 15) {
|
|
635
|
+
fprintf(
|
|
636
|
+
stderr,
|
|
637
|
+
"* HPACK STRING UNPACKING ERROR compressed example len %d != 15.\n",
|
|
638
|
+
tmp);
|
|
639
|
+
exit(-1);
|
|
640
|
+
}
|
|
641
|
+
if (memcmp(buffer, "www.example.com", 10)) {
|
|
642
|
+
fprintf(stderr,
|
|
643
|
+
"* HPACK STRING UNPACKING ERROR compressed example returned: "
|
|
644
|
+
"%.*s\n",
|
|
645
|
+
tmp, buffer);
|
|
646
|
+
exit(-1);
|
|
647
|
+
}
|
|
648
|
+
if (pos != 13) {
|
|
649
|
+
fprintf(stderr,
|
|
650
|
+
"* HPACK STRING UNPACKING FAILED(!) wrong reading position %zu "
|
|
651
|
+
"!= 13\n",
|
|
652
|
+
pos);
|
|
653
|
+
exit(-1);
|
|
654
|
+
}
|
|
655
|
+
}
|
|
656
|
+
|
|
657
|
+
if (1) {
|
|
658
|
+
char *str1 = "This is a string to be packed, either compressed or not.";
|
|
659
|
+
buf_pos = 0;
|
|
660
|
+
size_t i = 0;
|
|
661
|
+
const size_t repeats = 1024;
|
|
662
|
+
for (i = 0; i < repeats; i++) {
|
|
663
|
+
tmp = hpack_string_pack(buffer + buf_pos, limit - buf_pos, str1, 56,
|
|
664
|
+
(i & 1) == 1);
|
|
665
|
+
if (tmp == -1)
|
|
666
|
+
fprintf(stderr, "* HPACK STRING PACKING FAIL AT %lu\n", i);
|
|
667
|
+
else if ((size_t)tmp > limit - buf_pos)
|
|
668
|
+
break;
|
|
669
|
+
buf_pos += tmp;
|
|
670
|
+
}
|
|
671
|
+
int count = i;
|
|
672
|
+
buf_pos = 0;
|
|
673
|
+
while (i) {
|
|
674
|
+
char result[56];
|
|
675
|
+
memset(result, 0, 56);
|
|
676
|
+
--i;
|
|
677
|
+
tmp = hpack_string_unpack(result, 56, buffer, limit, &buf_pos);
|
|
678
|
+
if (tmp == -1) {
|
|
679
|
+
fprintf(stderr, "* HPACK STRING UNPACKING FAIL AT %lu\n",
|
|
680
|
+
(repeats - 1) - i);
|
|
681
|
+
exit(-1);
|
|
682
|
+
} else if (tmp != 56) {
|
|
683
|
+
fprintf(stderr,
|
|
684
|
+
"* HPACK STRING UNPACKING ERROR AT %zu - got string "
|
|
685
|
+
"length %u instead of 56: %.*s\n",
|
|
686
|
+
(repeats - 1) - i, tmp, 56, result);
|
|
687
|
+
exit(-1);
|
|
688
|
+
}
|
|
689
|
+
if (memcmp(str1, result, 56)) {
|
|
690
|
+
fprintf(stderr,
|
|
691
|
+
"* HPACK STRING UNPACKING ERROR AT %lu. Got (%u) %.*s\n",
|
|
692
|
+
(repeats - 1) - i, tmp, tmp, result);
|
|
693
|
+
exit(-1);
|
|
694
|
+
}
|
|
695
|
+
}
|
|
696
|
+
fprintf(stderr,
|
|
697
|
+
"* HPACK string primitive test complete (buffer used %u/%zu "
|
|
698
|
+
"strings)\n",
|
|
699
|
+
count, repeats);
|
|
700
|
+
}
|
|
701
|
+
}
|
|
702
|
+
}
|
|
703
|
+
#else
|
|
704
|
+
|
|
705
|
+
#define hpack_test()
|
|
706
|
+
|
|
707
|
+
#endif /* DEBUG */
|
|
708
|
+
|
|
709
|
+
/* *****************************************************************************
|
|
710
|
+
|
|
711
|
+
|
|
712
|
+
|
|
713
|
+
|
|
714
|
+
|
|
715
|
+
Auto-generate binary tree from table data
|
|
716
|
+
|
|
717
|
+
|
|
718
|
+
|
|
719
|
+
|
|
720
|
+
|
|
721
|
+
***************************************************************************** */
|
|
722
|
+
|
|
723
|
+
#if HPACK_BUILD_HPACK_STRUCT
|
|
724
|
+
|
|
725
|
+
/*
|
|
726
|
+
This section prints out the C code required to create a static, Array based,
|
|
727
|
+
binary tree with the following type / fields:
|
|
728
|
+
*/
|
|
729
|
+
|
|
730
|
+
#include <stdio.h>
|
|
731
|
+
|
|
732
|
+
typedef struct {
|
|
733
|
+
uint32_t code;
|
|
734
|
+
uint8_t bits;
|
|
735
|
+
int16_t value;
|
|
736
|
+
} huffman_code_s;
|
|
737
|
+
|
|
738
|
+
/* the huffman decoding binary tree type */
|
|
739
|
+
typedef struct {
|
|
740
|
+
int16_t value; // value, -1 == none.
|
|
741
|
+
uint8_t offset[2]; // offset for 0 and one. 0 == leaf node.
|
|
742
|
+
} huffman_decode_nc_s;
|
|
743
|
+
|
|
744
|
+
/** used to print the binary reverse testing */
|
|
745
|
+
static MAYBE_UNUSED void huffman__print_bin_num(uint32_t num, uint8_t bits) {
|
|
746
|
+
fprintf(stderr, "0b");
|
|
747
|
+
if (((32 - bits) & 31))
|
|
748
|
+
num <<= ((32 - bits) & 31);
|
|
749
|
+
for (size_t i = 0; i < bits; i++) {
|
|
750
|
+
if (num & (1 << (31 - i)))
|
|
751
|
+
fprintf(stderr, "1");
|
|
752
|
+
else
|
|
753
|
+
fprintf(stderr, "0");
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
static void huffman__print_unit(huffman_decode_nc_s d, size_t index,
|
|
758
|
+
size_t code, size_t bits) {
|
|
759
|
+
if (d.value != -1) {
|
|
760
|
+
fprintf(stderr,
|
|
761
|
+
" {.value = %d, .offset = {%zu, %zu}}, // [%zu]:", (int)d.value,
|
|
762
|
+
(size_t)d.offset[0], (size_t)d.offset[1], index);
|
|
763
|
+
huffman__print_bin_num(code, bits);
|
|
764
|
+
fprintf(stderr, "\n");
|
|
765
|
+
} else {
|
|
766
|
+
fprintf(stderr, " {.value = %d, .offset = {%zu, %zu}}, // [%zu]\n",
|
|
767
|
+
(int)d.value, (size_t)d.offset[0], (size_t)d.offset[1], index);
|
|
768
|
+
}
|
|
769
|
+
}
|
|
770
|
+
|
|
771
|
+
#define HUFFMAN_TREE_BUFFER (1 << 12)
|
|
772
|
+
|
|
773
|
+
void huffman__print_tree(void) {
|
|
774
|
+
/* The Huffman Encoding table was copied from
|
|
775
|
+
* http://httpwg.org/specs/rfc7541.html#huffman.code
|
|
776
|
+
*/
|
|
777
|
+
const huffman_encode_s encode_table[] = {
|
|
778
|
+
/* 257 elements, 0..256 all sym + EOS */
|
|
779
|
+
{0x1ff8U, 13}, {0x7fffd8U, 23}, {0xfffffe2U, 28}, {0xfffffe3U, 28},
|
|
780
|
+
{0xfffffe4U, 28}, {0xfffffe5U, 28}, {0xfffffe6U, 28}, {0xfffffe7U, 28},
|
|
781
|
+
{0xfffffe8U, 28}, {0xffffeaU, 24}, {0x3ffffffcU, 30}, {0xfffffe9U, 28},
|
|
782
|
+
{0xfffffeaU, 28}, {0x3ffffffdU, 30}, {0xfffffebU, 28}, {0xfffffecU, 28},
|
|
783
|
+
{0xfffffedU, 28}, {0xfffffeeU, 28}, {0xfffffefU, 28}, {0xffffff0U, 28},
|
|
784
|
+
{0xffffff1U, 28}, {0xffffff2U, 28}, {0x3ffffffeU, 30}, {0xffffff3U, 28},
|
|
785
|
+
{0xffffff4U, 28}, {0xffffff5U, 28}, {0xffffff6U, 28}, {0xffffff7U, 28},
|
|
786
|
+
{0xffffff8U, 28}, {0xffffff9U, 28}, {0xffffffaU, 28}, {0xffffffbU, 28},
|
|
787
|
+
{0x14U, 6}, {0x3f8U, 10}, {0x3f9U, 10}, {0xffaU, 12},
|
|
788
|
+
{0x1ff9U, 13}, {0x15U, 6}, {0xf8U, 8}, {0x7faU, 11},
|
|
789
|
+
{0x3faU, 10}, {0x3fbU, 10}, {0xf9U, 8}, {0x7fbU, 11},
|
|
790
|
+
{0xfaU, 8}, {0x16U, 6}, {0x17U, 6}, {0x18U, 6},
|
|
791
|
+
{0x0U, 5}, {0x1U, 5}, {0x2U, 5}, {0x19U, 6},
|
|
792
|
+
{0x1aU, 6}, {0x1bU, 6}, {0x1cU, 6}, {0x1dU, 6},
|
|
793
|
+
{0x1eU, 6}, {0x1fU, 6}, {0x5cU, 7}, {0xfbU, 8},
|
|
794
|
+
{0x7ffcU, 15}, {0x20U, 6}, {0xffbU, 12}, {0x3fcU, 10},
|
|
795
|
+
{0x1ffaU, 13}, {0x21U, 6}, {0x5dU, 7}, {0x5eU, 7},
|
|
796
|
+
{0x5fU, 7}, {0x60U, 7}, {0x61U, 7}, {0x62U, 7},
|
|
797
|
+
{0x63U, 7}, {0x64U, 7}, {0x65U, 7}, {0x66U, 7},
|
|
798
|
+
{0x67U, 7}, {0x68U, 7}, {0x69U, 7}, {0x6aU, 7},
|
|
799
|
+
{0x6bU, 7}, {0x6cU, 7}, {0x6dU, 7}, {0x6eU, 7},
|
|
800
|
+
{0x6fU, 7}, {0x70U, 7}, {0x71U, 7}, {0x72U, 7},
|
|
801
|
+
{0xfcU, 8}, {0x73U, 7}, {0xfdU, 8}, {0x1ffbU, 13},
|
|
802
|
+
{0x7fff0U, 19}, {0x1ffcU, 13}, {0x3ffcU, 14}, {0x22U, 6},
|
|
803
|
+
{0x7ffdU, 15}, {0x3U, 5}, {0x23U, 6}, {0x4U, 5},
|
|
804
|
+
{0x24U, 6}, {0x5U, 5}, {0x25U, 6}, {0x26U, 6},
|
|
805
|
+
{0x27U, 6}, {0x6U, 5}, {0x74U, 7}, {0x75U, 7},
|
|
806
|
+
{0x28U, 6}, {0x29U, 6}, {0x2aU, 6}, {0x7U, 5},
|
|
807
|
+
{0x2bU, 6}, {0x76U, 7}, {0x2cU, 6}, {0x8U, 5},
|
|
808
|
+
{0x9U, 5}, {0x2dU, 6}, {0x77U, 7}, {0x78U, 7},
|
|
809
|
+
{0x79U, 7}, {0x7aU, 7}, {0x7bU, 7}, {0x7ffeU, 15},
|
|
810
|
+
{0x7fcU, 11}, {0x3ffdU, 14}, {0x1ffdU, 13}, {0xffffffcU, 28},
|
|
811
|
+
{0xfffe6U, 20}, {0x3fffd2U, 22}, {0xfffe7U, 20}, {0xfffe8U, 20},
|
|
812
|
+
{0x3fffd3U, 22}, {0x3fffd4U, 22}, {0x3fffd5U, 22}, {0x7fffd9U, 23},
|
|
813
|
+
{0x3fffd6U, 22}, {0x7fffdaU, 23}, {0x7fffdbU, 23}, {0x7fffdcU, 23},
|
|
814
|
+
{0x7fffddU, 23}, {0x7fffdeU, 23}, {0xffffebU, 24}, {0x7fffdfU, 23},
|
|
815
|
+
{0xffffecU, 24}, {0xffffedU, 24}, {0x3fffd7U, 22}, {0x7fffe0U, 23},
|
|
816
|
+
{0xffffeeU, 24}, {0x7fffe1U, 23}, {0x7fffe2U, 23}, {0x7fffe3U, 23},
|
|
817
|
+
{0x7fffe4U, 23}, {0x1fffdcU, 21}, {0x3fffd8U, 22}, {0x7fffe5U, 23},
|
|
818
|
+
{0x3fffd9U, 22}, {0x7fffe6U, 23}, {0x7fffe7U, 23}, {0xffffefU, 24},
|
|
819
|
+
{0x3fffdaU, 22}, {0x1fffddU, 21}, {0xfffe9U, 20}, {0x3fffdbU, 22},
|
|
820
|
+
{0x3fffdcU, 22}, {0x7fffe8U, 23}, {0x7fffe9U, 23}, {0x1fffdeU, 21},
|
|
821
|
+
{0x7fffeaU, 23}, {0x3fffddU, 22}, {0x3fffdeU, 22}, {0xfffff0U, 24},
|
|
822
|
+
{0x1fffdfU, 21}, {0x3fffdfU, 22}, {0x7fffebU, 23}, {0x7fffecU, 23},
|
|
823
|
+
{0x1fffe0U, 21}, {0x1fffe1U, 21}, {0x3fffe0U, 22}, {0x1fffe2U, 21},
|
|
824
|
+
{0x7fffedU, 23}, {0x3fffe1U, 22}, {0x7fffeeU, 23}, {0x7fffefU, 23},
|
|
825
|
+
{0xfffeaU, 20}, {0x3fffe2U, 22}, {0x3fffe3U, 22}, {0x3fffe4U, 22},
|
|
826
|
+
{0x7ffff0U, 23}, {0x3fffe5U, 22}, {0x3fffe6U, 22}, {0x7ffff1U, 23},
|
|
827
|
+
{0x3ffffe0U, 26}, {0x3ffffe1U, 26}, {0xfffebU, 20}, {0x7fff1U, 19},
|
|
828
|
+
{0x3fffe7U, 22}, {0x7ffff2U, 23}, {0x3fffe8U, 22}, {0x1ffffecU, 25},
|
|
829
|
+
{0x3ffffe2U, 26}, {0x3ffffe3U, 26}, {0x3ffffe4U, 26}, {0x7ffffdeU, 27},
|
|
830
|
+
{0x7ffffdfU, 27}, {0x3ffffe5U, 26}, {0xfffff1U, 24}, {0x1ffffedU, 25},
|
|
831
|
+
{0x7fff2U, 19}, {0x1fffe3U, 21}, {0x3ffffe6U, 26}, {0x7ffffe0U, 27},
|
|
832
|
+
{0x7ffffe1U, 27}, {0x3ffffe7U, 26}, {0x7ffffe2U, 27}, {0xfffff2U, 24},
|
|
833
|
+
{0x1fffe4U, 21}, {0x1fffe5U, 21}, {0x3ffffe8U, 26}, {0x3ffffe9U, 26},
|
|
834
|
+
{0xffffffdU, 28}, {0x7ffffe3U, 27}, {0x7ffffe4U, 27}, {0x7ffffe5U, 27},
|
|
835
|
+
{0xfffecU, 20}, {0xfffff3U, 24}, {0xfffedU, 20}, {0x1fffe6U, 21},
|
|
836
|
+
{0x3fffe9U, 22}, {0x1fffe7U, 21}, {0x1fffe8U, 21}, {0x7ffff3U, 23},
|
|
837
|
+
{0x3fffeaU, 22}, {0x3fffebU, 22}, {0x1ffffeeU, 25}, {0x1ffffefU, 25},
|
|
838
|
+
{0xfffff4U, 24}, {0xfffff5U, 24}, {0x3ffffeaU, 26}, {0x7ffff4U, 23},
|
|
839
|
+
{0x3ffffebU, 26}, {0x7ffffe6U, 27}, {0x3ffffecU, 26}, {0x3ffffedU, 26},
|
|
840
|
+
{0x7ffffe7U, 27}, {0x7ffffe8U, 27}, {0x7ffffe9U, 27}, {0x7ffffeaU, 27},
|
|
841
|
+
{0x7ffffebU, 27}, {0xffffffeU, 28}, {0x7ffffecU, 27}, {0x7ffffedU, 27},
|
|
842
|
+
{0x7ffffeeU, 27}, {0x7ffffefU, 27}, {0x7fffff0U, 27}, {0x3ffffeeU, 26},
|
|
843
|
+
{0x3fffffffU, 30},
|
|
844
|
+
};
|
|
845
|
+
/* copy code list */
|
|
846
|
+
huffman_code_s ordered[257];
|
|
847
|
+
for (uint16_t i = 0; i < 257; ++i) {
|
|
848
|
+
ordered[i] = (huffman_code_s){
|
|
849
|
+
.value = i,
|
|
850
|
+
.bits = encode_table[i].bits,
|
|
851
|
+
.code = encode_table[i].code,
|
|
852
|
+
};
|
|
853
|
+
}
|
|
854
|
+
/* order list by code's bit order (0100 > 0011), use a bunch of CPU... */
|
|
855
|
+
{
|
|
856
|
+
uint16_t i = 0;
|
|
857
|
+
while (i < 256) {
|
|
858
|
+
if (ordered[i].code > ordered[i + 1].code) {
|
|
859
|
+
huffman_code_s tmp = ordered[i + 1];
|
|
860
|
+
++i;
|
|
861
|
+
do {
|
|
862
|
+
ordered[i] = ordered[i - 1];
|
|
863
|
+
} while (--i && ordered[i - 1].code > tmp.code);
|
|
864
|
+
ordered[i] = tmp;
|
|
865
|
+
}
|
|
866
|
+
++i;
|
|
867
|
+
}
|
|
868
|
+
}
|
|
869
|
+
/* build tree */
|
|
870
|
+
huffman_decode_nc_s tree[HUFFMAN_TREE_BUFFER];
|
|
871
|
+
size_t tree_len = 0;
|
|
872
|
+
for (int i = 0; i < HUFFMAN_TREE_BUFFER; ++i) {
|
|
873
|
+
tree[i] = (huffman_decode_nc_s){.value = -1,
|
|
874
|
+
.offset = {(uint8_t)-1, (uint8_t)-1}};
|
|
875
|
+
}
|
|
876
|
+
{
|
|
877
|
+
size_t max_offset = 0;
|
|
878
|
+
size_t next = 1;
|
|
879
|
+
for (int i = 0; i < 257; ++i) {
|
|
880
|
+
/* for each code point, map a tree path */
|
|
881
|
+
size_t pos = 0;
|
|
882
|
+
uint32_t code = ordered[i].code;
|
|
883
|
+
for (int b = 0; b < ordered[i].bits; ++b) {
|
|
884
|
+
if (code & (1ULL << (ordered[i].bits - 1))) {
|
|
885
|
+
/* map 1 branch */
|
|
886
|
+
if (tree[pos].offset[1] != (uint8_t)-1)
|
|
887
|
+
pos += tree[pos].offset[1];
|
|
888
|
+
else {
|
|
889
|
+
if (next - pos > max_offset)
|
|
890
|
+
max_offset = next - pos;
|
|
891
|
+
tree[pos].offset[1] = next - pos;
|
|
892
|
+
pos = next;
|
|
893
|
+
++next;
|
|
894
|
+
}
|
|
895
|
+
} else {
|
|
896
|
+
/* map 0 branch */
|
|
897
|
+
if (tree[pos].offset[0] != (uint8_t)-1)
|
|
898
|
+
pos += tree[pos].offset[0];
|
|
899
|
+
else {
|
|
900
|
+
if (next - pos > max_offset)
|
|
901
|
+
max_offset = next - pos;
|
|
902
|
+
tree[pos].offset[0] = next - pos;
|
|
903
|
+
pos = next;
|
|
904
|
+
++next;
|
|
905
|
+
}
|
|
906
|
+
}
|
|
907
|
+
code <<= 1;
|
|
908
|
+
}
|
|
909
|
+
tree[pos] = (huffman_decode_nc_s){.value = ordered[i].value};
|
|
910
|
+
}
|
|
911
|
+
fprintf(stderr, "Total tree length = %zu, max offset = %zu\n", next,
|
|
912
|
+
max_offset);
|
|
913
|
+
tree_len = next;
|
|
914
|
+
}
|
|
915
|
+
{
|
|
916
|
+
/* Validate tree */
|
|
917
|
+
for (int i = 0; i < 257; ++i) {
|
|
918
|
+
huffman_decode_nc_s *node = tree;
|
|
919
|
+
uint32_t code = ordered[i].code;
|
|
920
|
+
uint8_t consumed = 32 - ordered[i].bits;
|
|
921
|
+
code <<= consumed;
|
|
922
|
+
while (consumed < 32) {
|
|
923
|
+
node += node->offset[(code >> 31) & 1];
|
|
924
|
+
code <<= 1;
|
|
925
|
+
++consumed;
|
|
926
|
+
}
|
|
927
|
+
if (ordered[i].value != node->value) {
|
|
928
|
+
fprintf(stderr,
|
|
929
|
+
"ERROR building tree - validation error for %d (value: %d != "
|
|
930
|
+
"%d)\n",
|
|
931
|
+
i, node->value, ordered[i].value);
|
|
932
|
+
exit(-1);
|
|
933
|
+
}
|
|
934
|
+
}
|
|
935
|
+
}
|
|
936
|
+
fprintf(stderr, "***** Copy after this line ****\n\n"
|
|
937
|
+
"/** Static Huffman encoding map, left aligned */\n"
|
|
938
|
+
|
|
939
|
+
"static const huffman_encode_s huffman_encode_table[] = {\n");
|
|
940
|
+
for (size_t i = 0; i < 257; ++i) {
|
|
941
|
+
/* print huffman code left align */
|
|
942
|
+
fprintf(stderr, " {.code = 0x%.08X, .bits = %u}, // [%zu] \n",
|
|
943
|
+
(encode_table[i].code << (32 - encode_table[i].bits)),
|
|
944
|
+
encode_table[i].bits, i);
|
|
945
|
+
}
|
|
946
|
+
fprintf(stderr,
|
|
947
|
+
"};\n\n/** Static Huffman decoding tree, flattened as an array */\n"
|
|
948
|
+
|
|
949
|
+
"static const huffman_decode_s huffman_decode_tree[] = {\n");
|
|
950
|
+
for (size_t i = 0; i < tree_len; ++i) {
|
|
951
|
+
huffman__print_unit(
|
|
952
|
+
tree[i], i,
|
|
953
|
+
(tree[i].value == -1) ? 0 : encode_table[tree[i].value].code,
|
|
954
|
+
(tree[i].value == -1) ? 0 : encode_table[tree[i].value].bits);
|
|
955
|
+
}
|
|
956
|
+
fprintf(stderr, "};\n\n\n******************************************\n\n");
|
|
957
|
+
for (int i = 0; i < 256; ++i) {
|
|
958
|
+
uint8_t data[4] = {0};
|
|
959
|
+
uint8_t result = 0;
|
|
960
|
+
size_t r_pos = 0;
|
|
961
|
+
uint32_t code = ordered[i].code;
|
|
962
|
+
code <<= 32 - ordered[i].bits;
|
|
963
|
+
code |= (1UL << (32 - ordered[i].bits)) - 1;
|
|
964
|
+
data[0] = (code >> 24) & 0xFF;
|
|
965
|
+
data[1] = (code >> 16) & 0xFF;
|
|
966
|
+
data[2] = (code >> 8) & 0xFF;
|
|
967
|
+
data[3] = (code >> 0) & 0xFF;
|
|
968
|
+
hpack_huffman_unpack(&result, 1, &data, 4, &r_pos);
|
|
969
|
+
r_pos = 0;
|
|
970
|
+
if (result != ordered[i].value) {
|
|
971
|
+
fprintf(stderr, "ERR: (%u) %u != %u (%d, %d)\n", data[0], result,
|
|
972
|
+
ordered[i].value,
|
|
973
|
+
hpack_huffman_unpack(&result, 1, &data, 1, &r_pos), i);
|
|
974
|
+
exit(-1);
|
|
975
|
+
}
|
|
976
|
+
}
|
|
977
|
+
hpack_test();
|
|
978
|
+
}
|
|
979
|
+
|
|
980
|
+
int main(void) {
|
|
981
|
+
huffman__print_tree();
|
|
982
|
+
return 0;
|
|
983
|
+
}
|
|
984
|
+
|
|
985
|
+
#endif
|
|
986
|
+
|
|
987
|
+
/* *****************************************************************************
|
|
988
|
+
Paste auto-generated b-tree here:
|
|
989
|
+
*****************************************************************************
|
|
990
|
+
*/
|
|
991
|
+
|
|
992
|
+
/** Static Huffman encoding map, left aligned */
|
|
993
|
+
static const huffman_encode_s huffman_encode_table[] = {
|
|
994
|
+
{.code = 0xFFC00000, .bits = 13}, // [0]
|
|
995
|
+
{.code = 0xFFFFB000, .bits = 23}, // [1]
|
|
996
|
+
{.code = 0xFFFFFE20, .bits = 28}, // [2]
|
|
997
|
+
{.code = 0xFFFFFE30, .bits = 28}, // [3]
|
|
998
|
+
{.code = 0xFFFFFE40, .bits = 28}, // [4]
|
|
999
|
+
{.code = 0xFFFFFE50, .bits = 28}, // [5]
|
|
1000
|
+
{.code = 0xFFFFFE60, .bits = 28}, // [6]
|
|
1001
|
+
{.code = 0xFFFFFE70, .bits = 28}, // [7]
|
|
1002
|
+
{.code = 0xFFFFFE80, .bits = 28}, // [8]
|
|
1003
|
+
{.code = 0xFFFFEA00, .bits = 24}, // [9]
|
|
1004
|
+
{.code = 0xFFFFFFF0, .bits = 30}, // [10]
|
|
1005
|
+
{.code = 0xFFFFFE90, .bits = 28}, // [11]
|
|
1006
|
+
{.code = 0xFFFFFEA0, .bits = 28}, // [12]
|
|
1007
|
+
{.code = 0xFFFFFFF4, .bits = 30}, // [13]
|
|
1008
|
+
{.code = 0xFFFFFEB0, .bits = 28}, // [14]
|
|
1009
|
+
{.code = 0xFFFFFEC0, .bits = 28}, // [15]
|
|
1010
|
+
{.code = 0xFFFFFED0, .bits = 28}, // [16]
|
|
1011
|
+
{.code = 0xFFFFFEE0, .bits = 28}, // [17]
|
|
1012
|
+
{.code = 0xFFFFFEF0, .bits = 28}, // [18]
|
|
1013
|
+
{.code = 0xFFFFFF00, .bits = 28}, // [19]
|
|
1014
|
+
{.code = 0xFFFFFF10, .bits = 28}, // [20]
|
|
1015
|
+
{.code = 0xFFFFFF20, .bits = 28}, // [21]
|
|
1016
|
+
{.code = 0xFFFFFFF8, .bits = 30}, // [22]
|
|
1017
|
+
{.code = 0xFFFFFF30, .bits = 28}, // [23]
|
|
1018
|
+
{.code = 0xFFFFFF40, .bits = 28}, // [24]
|
|
1019
|
+
{.code = 0xFFFFFF50, .bits = 28}, // [25]
|
|
1020
|
+
{.code = 0xFFFFFF60, .bits = 28}, // [26]
|
|
1021
|
+
{.code = 0xFFFFFF70, .bits = 28}, // [27]
|
|
1022
|
+
{.code = 0xFFFFFF80, .bits = 28}, // [28]
|
|
1023
|
+
{.code = 0xFFFFFF90, .bits = 28}, // [29]
|
|
1024
|
+
{.code = 0xFFFFFFA0, .bits = 28}, // [30]
|
|
1025
|
+
{.code = 0xFFFFFFB0, .bits = 28}, // [31]
|
|
1026
|
+
{.code = 0x50000000, .bits = 6}, // [32]
|
|
1027
|
+
{.code = 0xFE000000, .bits = 10}, // [33]
|
|
1028
|
+
{.code = 0xFE400000, .bits = 10}, // [34]
|
|
1029
|
+
{.code = 0xFFA00000, .bits = 12}, // [35]
|
|
1030
|
+
{.code = 0xFFC80000, .bits = 13}, // [36]
|
|
1031
|
+
{.code = 0x54000000, .bits = 6}, // [37]
|
|
1032
|
+
{.code = 0xF8000000, .bits = 8}, // [38]
|
|
1033
|
+
{.code = 0xFF400000, .bits = 11}, // [39]
|
|
1034
|
+
{.code = 0xFE800000, .bits = 10}, // [40]
|
|
1035
|
+
{.code = 0xFEC00000, .bits = 10}, // [41]
|
|
1036
|
+
{.code = 0xF9000000, .bits = 8}, // [42]
|
|
1037
|
+
{.code = 0xFF600000, .bits = 11}, // [43]
|
|
1038
|
+
{.code = 0xFA000000, .bits = 8}, // [44]
|
|
1039
|
+
{.code = 0x58000000, .bits = 6}, // [45]
|
|
1040
|
+
{.code = 0x5C000000, .bits = 6}, // [46]
|
|
1041
|
+
{.code = 0x60000000, .bits = 6}, // [47]
|
|
1042
|
+
{.code = 0x00000000, .bits = 5}, // [48]
|
|
1043
|
+
{.code = 0x08000000, .bits = 5}, // [49]
|
|
1044
|
+
{.code = 0x10000000, .bits = 5}, // [50]
|
|
1045
|
+
{.code = 0x64000000, .bits = 6}, // [51]
|
|
1046
|
+
{.code = 0x68000000, .bits = 6}, // [52]
|
|
1047
|
+
{.code = 0x6C000000, .bits = 6}, // [53]
|
|
1048
|
+
{.code = 0x70000000, .bits = 6}, // [54]
|
|
1049
|
+
{.code = 0x74000000, .bits = 6}, // [55]
|
|
1050
|
+
{.code = 0x78000000, .bits = 6}, // [56]
|
|
1051
|
+
{.code = 0x7C000000, .bits = 6}, // [57]
|
|
1052
|
+
{.code = 0xB8000000, .bits = 7}, // [58]
|
|
1053
|
+
{.code = 0xFB000000, .bits = 8}, // [59]
|
|
1054
|
+
{.code = 0xFFF80000, .bits = 15}, // [60]
|
|
1055
|
+
{.code = 0x80000000, .bits = 6}, // [61]
|
|
1056
|
+
{.code = 0xFFB00000, .bits = 12}, // [62]
|
|
1057
|
+
{.code = 0xFF000000, .bits = 10}, // [63]
|
|
1058
|
+
{.code = 0xFFD00000, .bits = 13}, // [64]
|
|
1059
|
+
{.code = 0x84000000, .bits = 6}, // [65]
|
|
1060
|
+
{.code = 0xBA000000, .bits = 7}, // [66]
|
|
1061
|
+
{.code = 0xBC000000, .bits = 7}, // [67]
|
|
1062
|
+
{.code = 0xBE000000, .bits = 7}, // [68]
|
|
1063
|
+
{.code = 0xC0000000, .bits = 7}, // [69]
|
|
1064
|
+
{.code = 0xC2000000, .bits = 7}, // [70]
|
|
1065
|
+
{.code = 0xC4000000, .bits = 7}, // [71]
|
|
1066
|
+
{.code = 0xC6000000, .bits = 7}, // [72]
|
|
1067
|
+
{.code = 0xC8000000, .bits = 7}, // [73]
|
|
1068
|
+
{.code = 0xCA000000, .bits = 7}, // [74]
|
|
1069
|
+
{.code = 0xCC000000, .bits = 7}, // [75]
|
|
1070
|
+
{.code = 0xCE000000, .bits = 7}, // [76]
|
|
1071
|
+
{.code = 0xD0000000, .bits = 7}, // [77]
|
|
1072
|
+
{.code = 0xD2000000, .bits = 7}, // [78]
|
|
1073
|
+
{.code = 0xD4000000, .bits = 7}, // [79]
|
|
1074
|
+
{.code = 0xD6000000, .bits = 7}, // [80]
|
|
1075
|
+
{.code = 0xD8000000, .bits = 7}, // [81]
|
|
1076
|
+
{.code = 0xDA000000, .bits = 7}, // [82]
|
|
1077
|
+
{.code = 0xDC000000, .bits = 7}, // [83]
|
|
1078
|
+
{.code = 0xDE000000, .bits = 7}, // [84]
|
|
1079
|
+
{.code = 0xE0000000, .bits = 7}, // [85]
|
|
1080
|
+
{.code = 0xE2000000, .bits = 7}, // [86]
|
|
1081
|
+
{.code = 0xE4000000, .bits = 7}, // [87]
|
|
1082
|
+
{.code = 0xFC000000, .bits = 8}, // [88]
|
|
1083
|
+
{.code = 0xE6000000, .bits = 7}, // [89]
|
|
1084
|
+
{.code = 0xFD000000, .bits = 8}, // [90]
|
|
1085
|
+
{.code = 0xFFD80000, .bits = 13}, // [91]
|
|
1086
|
+
{.code = 0xFFFE0000, .bits = 19}, // [92]
|
|
1087
|
+
{.code = 0xFFE00000, .bits = 13}, // [93]
|
|
1088
|
+
{.code = 0xFFF00000, .bits = 14}, // [94]
|
|
1089
|
+
{.code = 0x88000000, .bits = 6}, // [95]
|
|
1090
|
+
{.code = 0xFFFA0000, .bits = 15}, // [96]
|
|
1091
|
+
{.code = 0x18000000, .bits = 5}, // [97]
|
|
1092
|
+
{.code = 0x8C000000, .bits = 6}, // [98]
|
|
1093
|
+
{.code = 0x20000000, .bits = 5}, // [99]
|
|
1094
|
+
{.code = 0x90000000, .bits = 6}, // [100]
|
|
1095
|
+
{.code = 0x28000000, .bits = 5}, // [101]
|
|
1096
|
+
{.code = 0x94000000, .bits = 6}, // [102]
|
|
1097
|
+
{.code = 0x98000000, .bits = 6}, // [103]
|
|
1098
|
+
{.code = 0x9C000000, .bits = 6}, // [104]
|
|
1099
|
+
{.code = 0x30000000, .bits = 5}, // [105]
|
|
1100
|
+
{.code = 0xE8000000, .bits = 7}, // [106]
|
|
1101
|
+
{.code = 0xEA000000, .bits = 7}, // [107]
|
|
1102
|
+
{.code = 0xA0000000, .bits = 6}, // [108]
|
|
1103
|
+
{.code = 0xA4000000, .bits = 6}, // [109]
|
|
1104
|
+
{.code = 0xA8000000, .bits = 6}, // [110]
|
|
1105
|
+
{.code = 0x38000000, .bits = 5}, // [111]
|
|
1106
|
+
{.code = 0xAC000000, .bits = 6}, // [112]
|
|
1107
|
+
{.code = 0xEC000000, .bits = 7}, // [113]
|
|
1108
|
+
{.code = 0xB0000000, .bits = 6}, // [114]
|
|
1109
|
+
{.code = 0x40000000, .bits = 5}, // [115]
|
|
1110
|
+
{.code = 0x48000000, .bits = 5}, // [116]
|
|
1111
|
+
{.code = 0xB4000000, .bits = 6}, // [117]
|
|
1112
|
+
{.code = 0xEE000000, .bits = 7}, // [118]
|
|
1113
|
+
{.code = 0xF0000000, .bits = 7}, // [119]
|
|
1114
|
+
{.code = 0xF2000000, .bits = 7}, // [120]
|
|
1115
|
+
{.code = 0xF4000000, .bits = 7}, // [121]
|
|
1116
|
+
{.code = 0xF6000000, .bits = 7}, // [122]
|
|
1117
|
+
{.code = 0xFFFC0000, .bits = 15}, // [123]
|
|
1118
|
+
{.code = 0xFF800000, .bits = 11}, // [124]
|
|
1119
|
+
{.code = 0xFFF40000, .bits = 14}, // [125]
|
|
1120
|
+
{.code = 0xFFE80000, .bits = 13}, // [126]
|
|
1121
|
+
{.code = 0xFFFFFFC0, .bits = 28}, // [127]
|
|
1122
|
+
{.code = 0xFFFE6000, .bits = 20}, // [128]
|
|
1123
|
+
{.code = 0xFFFF4800, .bits = 22}, // [129]
|
|
1124
|
+
{.code = 0xFFFE7000, .bits = 20}, // [130]
|
|
1125
|
+
{.code = 0xFFFE8000, .bits = 20}, // [131]
|
|
1126
|
+
{.code = 0xFFFF4C00, .bits = 22}, // [132]
|
|
1127
|
+
{.code = 0xFFFF5000, .bits = 22}, // [133]
|
|
1128
|
+
{.code = 0xFFFF5400, .bits = 22}, // [134]
|
|
1129
|
+
{.code = 0xFFFFB200, .bits = 23}, // [135]
|
|
1130
|
+
{.code = 0xFFFF5800, .bits = 22}, // [136]
|
|
1131
|
+
{.code = 0xFFFFB400, .bits = 23}, // [137]
|
|
1132
|
+
{.code = 0xFFFFB600, .bits = 23}, // [138]
|
|
1133
|
+
{.code = 0xFFFFB800, .bits = 23}, // [139]
|
|
1134
|
+
{.code = 0xFFFFBA00, .bits = 23}, // [140]
|
|
1135
|
+
{.code = 0xFFFFBC00, .bits = 23}, // [141]
|
|
1136
|
+
{.code = 0xFFFFEB00, .bits = 24}, // [142]
|
|
1137
|
+
{.code = 0xFFFFBE00, .bits = 23}, // [143]
|
|
1138
|
+
{.code = 0xFFFFEC00, .bits = 24}, // [144]
|
|
1139
|
+
{.code = 0xFFFFED00, .bits = 24}, // [145]
|
|
1140
|
+
{.code = 0xFFFF5C00, .bits = 22}, // [146]
|
|
1141
|
+
{.code = 0xFFFFC000, .bits = 23}, // [147]
|
|
1142
|
+
{.code = 0xFFFFEE00, .bits = 24}, // [148]
|
|
1143
|
+
{.code = 0xFFFFC200, .bits = 23}, // [149]
|
|
1144
|
+
{.code = 0xFFFFC400, .bits = 23}, // [150]
|
|
1145
|
+
{.code = 0xFFFFC600, .bits = 23}, // [151]
|
|
1146
|
+
{.code = 0xFFFFC800, .bits = 23}, // [152]
|
|
1147
|
+
{.code = 0xFFFEE000, .bits = 21}, // [153]
|
|
1148
|
+
{.code = 0xFFFF6000, .bits = 22}, // [154]
|
|
1149
|
+
{.code = 0xFFFFCA00, .bits = 23}, // [155]
|
|
1150
|
+
{.code = 0xFFFF6400, .bits = 22}, // [156]
|
|
1151
|
+
{.code = 0xFFFFCC00, .bits = 23}, // [157]
|
|
1152
|
+
{.code = 0xFFFFCE00, .bits = 23}, // [158]
|
|
1153
|
+
{.code = 0xFFFFEF00, .bits = 24}, // [159]
|
|
1154
|
+
{.code = 0xFFFF6800, .bits = 22}, // [160]
|
|
1155
|
+
{.code = 0xFFFEE800, .bits = 21}, // [161]
|
|
1156
|
+
{.code = 0xFFFE9000, .bits = 20}, // [162]
|
|
1157
|
+
{.code = 0xFFFF6C00, .bits = 22}, // [163]
|
|
1158
|
+
{.code = 0xFFFF7000, .bits = 22}, // [164]
|
|
1159
|
+
{.code = 0xFFFFD000, .bits = 23}, // [165]
|
|
1160
|
+
{.code = 0xFFFFD200, .bits = 23}, // [166]
|
|
1161
|
+
{.code = 0xFFFEF000, .bits = 21}, // [167]
|
|
1162
|
+
{.code = 0xFFFFD400, .bits = 23}, // [168]
|
|
1163
|
+
{.code = 0xFFFF7400, .bits = 22}, // [169]
|
|
1164
|
+
{.code = 0xFFFF7800, .bits = 22}, // [170]
|
|
1165
|
+
{.code = 0xFFFFF000, .bits = 24}, // [171]
|
|
1166
|
+
{.code = 0xFFFEF800, .bits = 21}, // [172]
|
|
1167
|
+
{.code = 0xFFFF7C00, .bits = 22}, // [173]
|
|
1168
|
+
{.code = 0xFFFFD600, .bits = 23}, // [174]
|
|
1169
|
+
{.code = 0xFFFFD800, .bits = 23}, // [175]
|
|
1170
|
+
{.code = 0xFFFF0000, .bits = 21}, // [176]
|
|
1171
|
+
{.code = 0xFFFF0800, .bits = 21}, // [177]
|
|
1172
|
+
{.code = 0xFFFF8000, .bits = 22}, // [178]
|
|
1173
|
+
{.code = 0xFFFF1000, .bits = 21}, // [179]
|
|
1174
|
+
{.code = 0xFFFFDA00, .bits = 23}, // [180]
|
|
1175
|
+
{.code = 0xFFFF8400, .bits = 22}, // [181]
|
|
1176
|
+
{.code = 0xFFFFDC00, .bits = 23}, // [182]
|
|
1177
|
+
{.code = 0xFFFFDE00, .bits = 23}, // [183]
|
|
1178
|
+
{.code = 0xFFFEA000, .bits = 20}, // [184]
|
|
1179
|
+
{.code = 0xFFFF8800, .bits = 22}, // [185]
|
|
1180
|
+
{.code = 0xFFFF8C00, .bits = 22}, // [186]
|
|
1181
|
+
{.code = 0xFFFF9000, .bits = 22}, // [187]
|
|
1182
|
+
{.code = 0xFFFFE000, .bits = 23}, // [188]
|
|
1183
|
+
{.code = 0xFFFF9400, .bits = 22}, // [189]
|
|
1184
|
+
{.code = 0xFFFF9800, .bits = 22}, // [190]
|
|
1185
|
+
{.code = 0xFFFFE200, .bits = 23}, // [191]
|
|
1186
|
+
{.code = 0xFFFFF800, .bits = 26}, // [192]
|
|
1187
|
+
{.code = 0xFFFFF840, .bits = 26}, // [193]
|
|
1188
|
+
{.code = 0xFFFEB000, .bits = 20}, // [194]
|
|
1189
|
+
{.code = 0xFFFE2000, .bits = 19}, // [195]
|
|
1190
|
+
{.code = 0xFFFF9C00, .bits = 22}, // [196]
|
|
1191
|
+
{.code = 0xFFFFE400, .bits = 23}, // [197]
|
|
1192
|
+
{.code = 0xFFFFA000, .bits = 22}, // [198]
|
|
1193
|
+
{.code = 0xFFFFF600, .bits = 25}, // [199]
|
|
1194
|
+
{.code = 0xFFFFF880, .bits = 26}, // [200]
|
|
1195
|
+
{.code = 0xFFFFF8C0, .bits = 26}, // [201]
|
|
1196
|
+
{.code = 0xFFFFF900, .bits = 26}, // [202]
|
|
1197
|
+
{.code = 0xFFFFFBC0, .bits = 27}, // [203]
|
|
1198
|
+
{.code = 0xFFFFFBE0, .bits = 27}, // [204]
|
|
1199
|
+
{.code = 0xFFFFF940, .bits = 26}, // [205]
|
|
1200
|
+
{.code = 0xFFFFF100, .bits = 24}, // [206]
|
|
1201
|
+
{.code = 0xFFFFF680, .bits = 25}, // [207]
|
|
1202
|
+
{.code = 0xFFFE4000, .bits = 19}, // [208]
|
|
1203
|
+
{.code = 0xFFFF1800, .bits = 21}, // [209]
|
|
1204
|
+
{.code = 0xFFFFF980, .bits = 26}, // [210]
|
|
1205
|
+
{.code = 0xFFFFFC00, .bits = 27}, // [211]
|
|
1206
|
+
{.code = 0xFFFFFC20, .bits = 27}, // [212]
|
|
1207
|
+
{.code = 0xFFFFF9C0, .bits = 26}, // [213]
|
|
1208
|
+
{.code = 0xFFFFFC40, .bits = 27}, // [214]
|
|
1209
|
+
{.code = 0xFFFFF200, .bits = 24}, // [215]
|
|
1210
|
+
{.code = 0xFFFF2000, .bits = 21}, // [216]
|
|
1211
|
+
{.code = 0xFFFF2800, .bits = 21}, // [217]
|
|
1212
|
+
{.code = 0xFFFFFA00, .bits = 26}, // [218]
|
|
1213
|
+
{.code = 0xFFFFFA40, .bits = 26}, // [219]
|
|
1214
|
+
{.code = 0xFFFFFFD0, .bits = 28}, // [220]
|
|
1215
|
+
{.code = 0xFFFFFC60, .bits = 27}, // [221]
|
|
1216
|
+
{.code = 0xFFFFFC80, .bits = 27}, // [222]
|
|
1217
|
+
{.code = 0xFFFFFCA0, .bits = 27}, // [223]
|
|
1218
|
+
{.code = 0xFFFEC000, .bits = 20}, // [224]
|
|
1219
|
+
{.code = 0xFFFFF300, .bits = 24}, // [225]
|
|
1220
|
+
{.code = 0xFFFED000, .bits = 20}, // [226]
|
|
1221
|
+
{.code = 0xFFFF3000, .bits = 21}, // [227]
|
|
1222
|
+
{.code = 0xFFFFA400, .bits = 22}, // [228]
|
|
1223
|
+
{.code = 0xFFFF3800, .bits = 21}, // [229]
|
|
1224
|
+
{.code = 0xFFFF4000, .bits = 21}, // [230]
|
|
1225
|
+
{.code = 0xFFFFE600, .bits = 23}, // [231]
|
|
1226
|
+
{.code = 0xFFFFA800, .bits = 22}, // [232]
|
|
1227
|
+
{.code = 0xFFFFAC00, .bits = 22}, // [233]
|
|
1228
|
+
{.code = 0xFFFFF700, .bits = 25}, // [234]
|
|
1229
|
+
{.code = 0xFFFFF780, .bits = 25}, // [235]
|
|
1230
|
+
{.code = 0xFFFFF400, .bits = 24}, // [236]
|
|
1231
|
+
{.code = 0xFFFFF500, .bits = 24}, // [237]
|
|
1232
|
+
{.code = 0xFFFFFA80, .bits = 26}, // [238]
|
|
1233
|
+
{.code = 0xFFFFE800, .bits = 23}, // [239]
|
|
1234
|
+
{.code = 0xFFFFFAC0, .bits = 26}, // [240]
|
|
1235
|
+
{.code = 0xFFFFFCC0, .bits = 27}, // [241]
|
|
1236
|
+
{.code = 0xFFFFFB00, .bits = 26}, // [242]
|
|
1237
|
+
{.code = 0xFFFFFB40, .bits = 26}, // [243]
|
|
1238
|
+
{.code = 0xFFFFFCE0, .bits = 27}, // [244]
|
|
1239
|
+
{.code = 0xFFFFFD00, .bits = 27}, // [245]
|
|
1240
|
+
{.code = 0xFFFFFD20, .bits = 27}, // [246]
|
|
1241
|
+
{.code = 0xFFFFFD40, .bits = 27}, // [247]
|
|
1242
|
+
{.code = 0xFFFFFD60, .bits = 27}, // [248]
|
|
1243
|
+
{.code = 0xFFFFFFE0, .bits = 28}, // [249]
|
|
1244
|
+
{.code = 0xFFFFFD80, .bits = 27}, // [250]
|
|
1245
|
+
{.code = 0xFFFFFDA0, .bits = 27}, // [251]
|
|
1246
|
+
{.code = 0xFFFFFDC0, .bits = 27}, // [252]
|
|
1247
|
+
{.code = 0xFFFFFDE0, .bits = 27}, // [253]
|
|
1248
|
+
{.code = 0xFFFFFE00, .bits = 27}, // [254]
|
|
1249
|
+
{.code = 0xFFFFFB80, .bits = 26}, // [255]
|
|
1250
|
+
{.code = 0xFFFFFFFC, .bits = 30}, // [256]
|
|
1251
|
+
};
|
|
1252
|
+
|
|
1253
|
+
/** Static Huffman decoding tree, flattened as an array */
|
|
1254
|
+
static const huffman_decode_s huffman_decode_tree[] = {
|
|
1255
|
+
{.value = -1, .offset = {1, 44}}, // [0]
|
|
1256
|
+
{.value = -1, .offset = {1, 16}}, // [1]
|
|
1257
|
+
{.value = -1, .offset = {1, 8}}, // [2]
|
|
1258
|
+
{.value = -1, .offset = {1, 4}}, // [3]
|
|
1259
|
+
{.value = -1, .offset = {1, 2}}, // [4]
|
|
1260
|
+
{.value = 48, .offset = {0, 0}}, // [5]:0b00000
|
|
1261
|
+
{.value = 49, .offset = {0, 0}}, // [6]:0b00001
|
|
1262
|
+
{.value = -1, .offset = {1, 2}}, // [7]
|
|
1263
|
+
{.value = 50, .offset = {0, 0}}, // [8]:0b00010
|
|
1264
|
+
{.value = 97, .offset = {0, 0}}, // [9]:0b00011
|
|
1265
|
+
{.value = -1, .offset = {1, 4}}, // [10]
|
|
1266
|
+
{.value = -1, .offset = {1, 2}}, // [11]
|
|
1267
|
+
{.value = 99, .offset = {0, 0}}, // [12]:0b00100
|
|
1268
|
+
{.value = 101, .offset = {0, 0}}, // [13]:0b00101
|
|
1269
|
+
{.value = -1, .offset = {1, 2}}, // [14]
|
|
1270
|
+
{.value = 105, .offset = {0, 0}}, // [15]:0b00110
|
|
1271
|
+
{.value = 111, .offset = {0, 0}}, // [16]:0b00111
|
|
1272
|
+
{.value = -1, .offset = {1, 12}}, // [17]
|
|
1273
|
+
{.value = -1, .offset = {1, 4}}, // [18]
|
|
1274
|
+
{.value = -1, .offset = {1, 2}}, // [19]
|
|
1275
|
+
{.value = 115, .offset = {0, 0}}, // [20]:0b01000
|
|
1276
|
+
{.value = 116, .offset = {0, 0}}, // [21]:0b01001
|
|
1277
|
+
{.value = -1, .offset = {1, 4}}, // [22]
|
|
1278
|
+
{.value = -1, .offset = {1, 2}}, // [23]
|
|
1279
|
+
{.value = 32, .offset = {0, 0}}, // [24]:0b010100
|
|
1280
|
+
{.value = 37, .offset = {0, 0}}, // [25]:0b010101
|
|
1281
|
+
{.value = -1, .offset = {1, 2}}, // [26]
|
|
1282
|
+
{.value = 45, .offset = {0, 0}}, // [27]:0b010110
|
|
1283
|
+
{.value = 46, .offset = {0, 0}}, // [28]:0b010111
|
|
1284
|
+
{.value = -1, .offset = {1, 8}}, // [29]
|
|
1285
|
+
{.value = -1, .offset = {1, 4}}, // [30]
|
|
1286
|
+
{.value = -1, .offset = {1, 2}}, // [31]
|
|
1287
|
+
{.value = 47, .offset = {0, 0}}, // [32]:0b011000
|
|
1288
|
+
{.value = 51, .offset = {0, 0}}, // [33]:0b011001
|
|
1289
|
+
{.value = -1, .offset = {1, 2}}, // [34]
|
|
1290
|
+
{.value = 52, .offset = {0, 0}}, // [35]:0b011010
|
|
1291
|
+
{.value = 53, .offset = {0, 0}}, // [36]:0b011011
|
|
1292
|
+
{.value = -1, .offset = {1, 4}}, // [37]
|
|
1293
|
+
{.value = -1, .offset = {1, 2}}, // [38]
|
|
1294
|
+
{.value = 54, .offset = {0, 0}}, // [39]:0b011100
|
|
1295
|
+
{.value = 55, .offset = {0, 0}}, // [40]:0b011101
|
|
1296
|
+
{.value = -1, .offset = {1, 2}}, // [41]
|
|
1297
|
+
{.value = 56, .offset = {0, 0}}, // [42]:0b011110
|
|
1298
|
+
{.value = 57, .offset = {0, 0}}, // [43]:0b011111
|
|
1299
|
+
{.value = -1, .offset = {1, 36}}, // [44]
|
|
1300
|
+
{.value = -1, .offset = {1, 16}}, // [45]
|
|
1301
|
+
{.value = -1, .offset = {1, 8}}, // [46]
|
|
1302
|
+
{.value = -1, .offset = {1, 4}}, // [47]
|
|
1303
|
+
{.value = -1, .offset = {1, 2}}, // [48]
|
|
1304
|
+
{.value = 61, .offset = {0, 0}}, // [49]:0b100000
|
|
1305
|
+
{.value = 65, .offset = {0, 0}}, // [50]:0b100001
|
|
1306
|
+
{.value = -1, .offset = {1, 2}}, // [51]
|
|
1307
|
+
{.value = 95, .offset = {0, 0}}, // [52]:0b100010
|
|
1308
|
+
{.value = 98, .offset = {0, 0}}, // [53]:0b100011
|
|
1309
|
+
{.value = -1, .offset = {1, 4}}, // [54]
|
|
1310
|
+
{.value = -1, .offset = {1, 2}}, // [55]
|
|
1311
|
+
{.value = 100, .offset = {0, 0}}, // [56]:0b100100
|
|
1312
|
+
{.value = 102, .offset = {0, 0}}, // [57]:0b100101
|
|
1313
|
+
{.value = -1, .offset = {1, 2}}, // [58]
|
|
1314
|
+
{.value = 103, .offset = {0, 0}}, // [59]:0b100110
|
|
1315
|
+
{.value = 104, .offset = {0, 0}}, // [60]:0b100111
|
|
1316
|
+
{.value = -1, .offset = {1, 8}}, // [61]
|
|
1317
|
+
{.value = -1, .offset = {1, 4}}, // [62]
|
|
1318
|
+
{.value = -1, .offset = {1, 2}}, // [63]
|
|
1319
|
+
{.value = 108, .offset = {0, 0}}, // [64]:0b101000
|
|
1320
|
+
{.value = 109, .offset = {0, 0}}, // [65]:0b101001
|
|
1321
|
+
{.value = -1, .offset = {1, 2}}, // [66]
|
|
1322
|
+
{.value = 110, .offset = {0, 0}}, // [67]:0b101010
|
|
1323
|
+
{.value = 112, .offset = {0, 0}}, // [68]:0b101011
|
|
1324
|
+
{.value = -1, .offset = {1, 4}}, // [69]
|
|
1325
|
+
{.value = -1, .offset = {1, 2}}, // [70]
|
|
1326
|
+
{.value = 114, .offset = {0, 0}}, // [71]:0b101100
|
|
1327
|
+
{.value = 117, .offset = {0, 0}}, // [72]:0b101101
|
|
1328
|
+
{.value = -1, .offset = {1, 4}}, // [73]
|
|
1329
|
+
{.value = -1, .offset = {1, 2}}, // [74]
|
|
1330
|
+
{.value = 58, .offset = {0, 0}}, // [75]:0b1011100
|
|
1331
|
+
{.value = 66, .offset = {0, 0}}, // [76]:0b1011101
|
|
1332
|
+
{.value = -1, .offset = {1, 2}}, // [77]
|
|
1333
|
+
{.value = 67, .offset = {0, 0}}, // [78]:0b1011110
|
|
1334
|
+
{.value = 68, .offset = {0, 0}}, // [79]:0b1011111
|
|
1335
|
+
{.value = -1, .offset = {1, 32}}, // [80]
|
|
1336
|
+
{.value = -1, .offset = {1, 16}}, // [81]
|
|
1337
|
+
{.value = -1, .offset = {1, 8}}, // [82]
|
|
1338
|
+
{.value = -1, .offset = {1, 4}}, // [83]
|
|
1339
|
+
{.value = -1, .offset = {1, 2}}, // [84]
|
|
1340
|
+
{.value = 69, .offset = {0, 0}}, // [85]:0b1100000
|
|
1341
|
+
{.value = 70, .offset = {0, 0}}, // [86]:0b1100001
|
|
1342
|
+
{.value = -1, .offset = {1, 2}}, // [87]
|
|
1343
|
+
{.value = 71, .offset = {0, 0}}, // [88]:0b1100010
|
|
1344
|
+
{.value = 72, .offset = {0, 0}}, // [89]:0b1100011
|
|
1345
|
+
{.value = -1, .offset = {1, 4}}, // [90]
|
|
1346
|
+
{.value = -1, .offset = {1, 2}}, // [91]
|
|
1347
|
+
{.value = 73, .offset = {0, 0}}, // [92]:0b1100100
|
|
1348
|
+
{.value = 74, .offset = {0, 0}}, // [93]:0b1100101
|
|
1349
|
+
{.value = -1, .offset = {1, 2}}, // [94]
|
|
1350
|
+
{.value = 75, .offset = {0, 0}}, // [95]:0b1100110
|
|
1351
|
+
{.value = 76, .offset = {0, 0}}, // [96]:0b1100111
|
|
1352
|
+
{.value = -1, .offset = {1, 8}}, // [97]
|
|
1353
|
+
{.value = -1, .offset = {1, 4}}, // [98]
|
|
1354
|
+
{.value = -1, .offset = {1, 2}}, // [99]
|
|
1355
|
+
{.value = 77, .offset = {0, 0}}, // [100]:0b1101000
|
|
1356
|
+
{.value = 78, .offset = {0, 0}}, // [101]:0b1101001
|
|
1357
|
+
{.value = -1, .offset = {1, 2}}, // [102]
|
|
1358
|
+
{.value = 79, .offset = {0, 0}}, // [103]:0b1101010
|
|
1359
|
+
{.value = 80, .offset = {0, 0}}, // [104]:0b1101011
|
|
1360
|
+
{.value = -1, .offset = {1, 4}}, // [105]
|
|
1361
|
+
{.value = -1, .offset = {1, 2}}, // [106]
|
|
1362
|
+
{.value = 81, .offset = {0, 0}}, // [107]:0b1101100
|
|
1363
|
+
{.value = 82, .offset = {0, 0}}, // [108]:0b1101101
|
|
1364
|
+
{.value = -1, .offset = {1, 2}}, // [109]
|
|
1365
|
+
{.value = 83, .offset = {0, 0}}, // [110]:0b1101110
|
|
1366
|
+
{.value = 84, .offset = {0, 0}}, // [111]:0b1101111
|
|
1367
|
+
{.value = -1, .offset = {1, 16}}, // [112]
|
|
1368
|
+
{.value = -1, .offset = {1, 8}}, // [113]
|
|
1369
|
+
{.value = -1, .offset = {1, 4}}, // [114]
|
|
1370
|
+
{.value = -1, .offset = {1, 2}}, // [115]
|
|
1371
|
+
{.value = 85, .offset = {0, 0}}, // [116]:0b1110000
|
|
1372
|
+
{.value = 86, .offset = {0, 0}}, // [117]:0b1110001
|
|
1373
|
+
{.value = -1, .offset = {1, 2}}, // [118]
|
|
1374
|
+
{.value = 87, .offset = {0, 0}}, // [119]:0b1110010
|
|
1375
|
+
{.value = 89, .offset = {0, 0}}, // [120]:0b1110011
|
|
1376
|
+
{.value = -1, .offset = {1, 4}}, // [121]
|
|
1377
|
+
{.value = -1, .offset = {1, 2}}, // [122]
|
|
1378
|
+
{.value = 106, .offset = {0, 0}}, // [123]:0b1110100
|
|
1379
|
+
{.value = 107, .offset = {0, 0}}, // [124]:0b1110101
|
|
1380
|
+
{.value = -1, .offset = {1, 2}}, // [125]
|
|
1381
|
+
{.value = 113, .offset = {0, 0}}, // [126]:0b1110110
|
|
1382
|
+
{.value = 118, .offset = {0, 0}}, // [127]:0b1110111
|
|
1383
|
+
{.value = -1, .offset = {1, 8}}, // [128]
|
|
1384
|
+
{.value = -1, .offset = {1, 4}}, // [129]
|
|
1385
|
+
{.value = -1, .offset = {1, 2}}, // [130]
|
|
1386
|
+
{.value = 119, .offset = {0, 0}}, // [131]:0b1111000
|
|
1387
|
+
{.value = 120, .offset = {0, 0}}, // [132]:0b1111001
|
|
1388
|
+
{.value = -1, .offset = {1, 2}}, // [133]
|
|
1389
|
+
{.value = 121, .offset = {0, 0}}, // [134]:0b1111010
|
|
1390
|
+
{.value = 122, .offset = {0, 0}}, // [135]:0b1111011
|
|
1391
|
+
{.value = -1, .offset = {1, 8}}, // [136]
|
|
1392
|
+
{.value = -1, .offset = {1, 4}}, // [137]
|
|
1393
|
+
{.value = -1, .offset = {1, 2}}, // [138]
|
|
1394
|
+
{.value = 38, .offset = {0, 0}}, // [139]:0b11111000
|
|
1395
|
+
{.value = 42, .offset = {0, 0}}, // [140]:0b11111001
|
|
1396
|
+
{.value = -1, .offset = {1, 2}}, // [141]
|
|
1397
|
+
{.value = 44, .offset = {0, 0}}, // [142]:0b11111010
|
|
1398
|
+
{.value = 59, .offset = {0, 0}}, // [143]:0b11111011
|
|
1399
|
+
{.value = -1, .offset = {1, 4}}, // [144]
|
|
1400
|
+
{.value = -1, .offset = {1, 2}}, // [145]
|
|
1401
|
+
{.value = 88, .offset = {0, 0}}, // [146]:0b11111100
|
|
1402
|
+
{.value = 90, .offset = {0, 0}}, // [147]:0b11111101
|
|
1403
|
+
{.value = -1, .offset = {1, 8}}, // [148]
|
|
1404
|
+
{.value = -1, .offset = {1, 4}}, // [149]
|
|
1405
|
+
{.value = -1, .offset = {1, 2}}, // [150]
|
|
1406
|
+
{.value = 33, .offset = {0, 0}}, // [151]:0b1111111000
|
|
1407
|
+
{.value = 34, .offset = {0, 0}}, // [152]:0b1111111001
|
|
1408
|
+
{.value = -1, .offset = {1, 2}}, // [153]
|
|
1409
|
+
{.value = 40, .offset = {0, 0}}, // [154]:0b1111111010
|
|
1410
|
+
{.value = 41, .offset = {0, 0}}, // [155]:0b1111111011
|
|
1411
|
+
{.value = -1, .offset = {1, 6}}, // [156]
|
|
1412
|
+
{.value = -1, .offset = {1, 2}}, // [157]
|
|
1413
|
+
{.value = 63, .offset = {0, 0}}, // [158]:0b1111111100
|
|
1414
|
+
{.value = -1, .offset = {1, 2}}, // [159]
|
|
1415
|
+
{.value = 39, .offset = {0, 0}}, // [160]:0b11111111010
|
|
1416
|
+
{.value = 43, .offset = {0, 0}}, // [161]:0b11111111011
|
|
1417
|
+
{.value = -1, .offset = {1, 6}}, // [162]
|
|
1418
|
+
{.value = -1, .offset = {1, 2}}, // [163]
|
|
1419
|
+
{.value = 124, .offset = {0, 0}}, // [164]:0b11111111100
|
|
1420
|
+
{.value = -1, .offset = {1, 2}}, // [165]
|
|
1421
|
+
{.value = 35, .offset = {0, 0}}, // [166]:0b111111111010
|
|
1422
|
+
{.value = 62, .offset = {0, 0}}, // [167]:0b111111111011
|
|
1423
|
+
{.value = -1, .offset = {1, 8}}, // [168]
|
|
1424
|
+
{.value = -1, .offset = {1, 4}}, // [169]
|
|
1425
|
+
{.value = -1, .offset = {1, 2}}, // [170]
|
|
1426
|
+
{.value = 0, .offset = {0, 0}}, // [171]:0b1111111111000
|
|
1427
|
+
{.value = 36, .offset = {0, 0}}, // [172]:0b1111111111001
|
|
1428
|
+
{.value = -1, .offset = {1, 2}}, // [173]
|
|
1429
|
+
{.value = 64, .offset = {0, 0}}, // [174]:0b1111111111010
|
|
1430
|
+
{.value = 91, .offset = {0, 0}}, // [175]:0b1111111111011
|
|
1431
|
+
{.value = -1, .offset = {1, 4}}, // [176]
|
|
1432
|
+
{.value = -1, .offset = {1, 2}}, // [177]
|
|
1433
|
+
{.value = 93, .offset = {0, 0}}, // [178]:0b1111111111100
|
|
1434
|
+
{.value = 126, .offset = {0, 0}}, // [179]:0b1111111111101
|
|
1435
|
+
{.value = -1, .offset = {1, 4}}, // [180]
|
|
1436
|
+
{.value = -1, .offset = {1, 2}}, // [181]
|
|
1437
|
+
{.value = 94, .offset = {0, 0}}, // [182]:0b11111111111100
|
|
1438
|
+
{.value = 125, .offset = {0, 0}}, // [183]:0b11111111111101
|
|
1439
|
+
{.value = -1, .offset = {1, 4}}, // [184]
|
|
1440
|
+
{.value = -1, .offset = {1, 2}}, // [185]
|
|
1441
|
+
{.value = 60, .offset = {0, 0}}, // [186]:0b111111111111100
|
|
1442
|
+
{.value = 96, .offset = {0, 0}}, // [187]:0b111111111111101
|
|
1443
|
+
{.value = -1, .offset = {1, 2}}, // [188]
|
|
1444
|
+
{.value = 123, .offset = {0, 0}}, // [189]:0b111111111111110
|
|
1445
|
+
{.value = -1, .offset = {1, 30}}, // [190]
|
|
1446
|
+
{.value = -1, .offset = {1, 10}}, // [191]
|
|
1447
|
+
{.value = -1, .offset = {1, 4}}, // [192]
|
|
1448
|
+
{.value = -1, .offset = {1, 2}}, // [193]
|
|
1449
|
+
{.value = 92, .offset = {0, 0}}, // [194]:0b1111111111111110000
|
|
1450
|
+
{.value = 195, .offset = {0, 0}}, // [195]:0b1111111111111110001
|
|
1451
|
+
{.value = -1, .offset = {1, 2}}, // [196]
|
|
1452
|
+
{.value = 208, .offset = {0, 0}}, // [197]:0b1111111111111110010
|
|
1453
|
+
{.value = -1, .offset = {1, 2}}, // [198]
|
|
1454
|
+
{.value = 128, .offset = {0, 0}}, // [199]:0b11111111111111100110
|
|
1455
|
+
{.value = 130, .offset = {0, 0}}, // [200]:0b11111111111111100111
|
|
1456
|
+
{.value = -1, .offset = {1, 8}}, // [201]
|
|
1457
|
+
{.value = -1, .offset = {1, 4}}, // [202]
|
|
1458
|
+
{.value = -1, .offset = {1, 2}}, // [203]
|
|
1459
|
+
{.value = 131, .offset = {0, 0}}, // [204]:0b11111111111111101000
|
|
1460
|
+
{.value = 162, .offset = {0, 0}}, // [205]:0b11111111111111101001
|
|
1461
|
+
{.value = -1, .offset = {1, 2}}, // [206]
|
|
1462
|
+
{.value = 184, .offset = {0, 0}}, // [207]:0b11111111111111101010
|
|
1463
|
+
{.value = 194, .offset = {0, 0}}, // [208]:0b11111111111111101011
|
|
1464
|
+
{.value = -1, .offset = {1, 4}}, // [209]
|
|
1465
|
+
{.value = -1, .offset = {1, 2}}, // [210]
|
|
1466
|
+
{.value = 224, .offset = {0, 0}}, // [211]:0b11111111111111101100
|
|
1467
|
+
{.value = 226, .offset = {0, 0}}, // [212]:0b11111111111111101101
|
|
1468
|
+
{.value = -1, .offset = {1, 4}}, // [213]
|
|
1469
|
+
{.value = -1, .offset = {1, 2}}, // [214]
|
|
1470
|
+
{.value = 153, .offset = {0, 0}}, // [215]:0b111111111111111011100
|
|
1471
|
+
{.value = 161, .offset = {0, 0}}, // [216]:0b111111111111111011101
|
|
1472
|
+
{.value = -1, .offset = {1, 2}}, // [217]
|
|
1473
|
+
{.value = 167, .offset = {0, 0}}, // [218]:0b111111111111111011110
|
|
1474
|
+
{.value = 172, .offset = {0, 0}}, // [219]:0b111111111111111011111
|
|
1475
|
+
{.value = -1, .offset = {1, 46}}, // [220]
|
|
1476
|
+
{.value = -1, .offset = {1, 16}}, // [221]
|
|
1477
|
+
{.value = -1, .offset = {1, 8}}, // [222]
|
|
1478
|
+
{.value = -1, .offset = {1, 4}}, // [223]
|
|
1479
|
+
{.value = -1, .offset = {1, 2}}, // [224]
|
|
1480
|
+
{.value = 176, .offset = {0, 0}}, // [225]:0b111111111111111100000
|
|
1481
|
+
{.value = 177, .offset = {0, 0}}, // [226]:0b111111111111111100001
|
|
1482
|
+
{.value = -1, .offset = {1, 2}}, // [227]
|
|
1483
|
+
{.value = 179, .offset = {0, 0}}, // [228]:0b111111111111111100010
|
|
1484
|
+
{.value = 209, .offset = {0, 0}}, // [229]:0b111111111111111100011
|
|
1485
|
+
{.value = -1, .offset = {1, 4}}, // [230]
|
|
1486
|
+
{.value = -1, .offset = {1, 2}}, // [231]
|
|
1487
|
+
{.value = 216, .offset = {0, 0}}, // [232]:0b111111111111111100100
|
|
1488
|
+
{.value = 217, .offset = {0, 0}}, // [233]:0b111111111111111100101
|
|
1489
|
+
{.value = -1, .offset = {1, 2}}, // [234]
|
|
1490
|
+
{.value = 227, .offset = {0, 0}}, // [235]:0b111111111111111100110
|
|
1491
|
+
{.value = 229, .offset = {0, 0}}, // [236]:0b111111111111111100111
|
|
1492
|
+
{.value = -1, .offset = {1, 14}}, // [237]
|
|
1493
|
+
{.value = -1, .offset = {1, 6}}, // [238]
|
|
1494
|
+
{.value = -1, .offset = {1, 2}}, // [239]
|
|
1495
|
+
{.value = 230, .offset = {0, 0}}, // [240]:0b111111111111111101000
|
|
1496
|
+
{.value = -1, .offset = {1, 2}}, // [241]
|
|
1497
|
+
{.value = 129, .offset = {0, 0}}, // [242]:0b1111111111111111010010
|
|
1498
|
+
{.value = 132, .offset = {0, 0}}, // [243]:0b1111111111111111010011
|
|
1499
|
+
{.value = -1, .offset = {1, 4}}, // [244]
|
|
1500
|
+
{.value = -1, .offset = {1, 2}}, // [245]
|
|
1501
|
+
{.value = 133, .offset = {0, 0}}, // [246]:0b1111111111111111010100
|
|
1502
|
+
{.value = 134, .offset = {0, 0}}, // [247]:0b1111111111111111010101
|
|
1503
|
+
{.value = -1, .offset = {1, 2}}, // [248]
|
|
1504
|
+
{.value = 136, .offset = {0, 0}}, // [249]:0b1111111111111111010110
|
|
1505
|
+
{.value = 146, .offset = {0, 0}}, // [250]:0b1111111111111111010111
|
|
1506
|
+
{.value = -1, .offset = {1, 8}}, // [251]
|
|
1507
|
+
{.value = -1, .offset = {1, 4}}, // [252]
|
|
1508
|
+
{.value = -1, .offset = {1, 2}}, // [253]
|
|
1509
|
+
{.value = 154, .offset = {0, 0}}, // [254]:0b1111111111111111011000
|
|
1510
|
+
{.value = 156, .offset = {0, 0}}, // [255]:0b1111111111111111011001
|
|
1511
|
+
{.value = -1, .offset = {1, 2}}, // [256]
|
|
1512
|
+
{.value = 160, .offset = {0, 0}}, // [257]:0b1111111111111111011010
|
|
1513
|
+
{.value = 163, .offset = {0, 0}}, // [258]:0b1111111111111111011011
|
|
1514
|
+
{.value = -1, .offset = {1, 4}}, // [259]
|
|
1515
|
+
{.value = -1, .offset = {1, 2}}, // [260]
|
|
1516
|
+
{.value = 164, .offset = {0, 0}}, // [261]:0b1111111111111111011100
|
|
1517
|
+
{.value = 169, .offset = {0, 0}}, // [262]:0b1111111111111111011101
|
|
1518
|
+
{.value = -1, .offset = {1, 2}}, // [263]
|
|
1519
|
+
{.value = 170, .offset = {0, 0}}, // [264]:0b1111111111111111011110
|
|
1520
|
+
{.value = 173, .offset = {0, 0}}, // [265]:0b1111111111111111011111
|
|
1521
|
+
{.value = -1, .offset = {1, 40}}, // [266]
|
|
1522
|
+
{.value = -1, .offset = {1, 16}}, // [267]
|
|
1523
|
+
{.value = -1, .offset = {1, 8}}, // [268]
|
|
1524
|
+
{.value = -1, .offset = {1, 4}}, // [269]
|
|
1525
|
+
{.value = -1, .offset = {1, 2}}, // [270]
|
|
1526
|
+
{.value = 178, .offset = {0, 0}}, // [271]:0b1111111111111111100000
|
|
1527
|
+
{.value = 181, .offset = {0, 0}}, // [272]:0b1111111111111111100001
|
|
1528
|
+
{.value = -1, .offset = {1, 2}}, // [273]
|
|
1529
|
+
{.value = 185, .offset = {0, 0}}, // [274]:0b1111111111111111100010
|
|
1530
|
+
{.value = 186, .offset = {0, 0}}, // [275]:0b1111111111111111100011
|
|
1531
|
+
{.value = -1, .offset = {1, 4}}, // [276]
|
|
1532
|
+
{.value = -1, .offset = {1, 2}}, // [277]
|
|
1533
|
+
{.value = 187, .offset = {0, 0}}, // [278]:0b1111111111111111100100
|
|
1534
|
+
{.value = 189, .offset = {0, 0}}, // [279]:0b1111111111111111100101
|
|
1535
|
+
{.value = -1, .offset = {1, 2}}, // [280]
|
|
1536
|
+
{.value = 190, .offset = {0, 0}}, // [281]:0b1111111111111111100110
|
|
1537
|
+
{.value = 196, .offset = {0, 0}}, // [282]:0b1111111111111111100111
|
|
1538
|
+
{.value = -1, .offset = {1, 8}}, // [283]
|
|
1539
|
+
{.value = -1, .offset = {1, 4}}, // [284]
|
|
1540
|
+
{.value = -1, .offset = {1, 2}}, // [285]
|
|
1541
|
+
{.value = 198, .offset = {0, 0}}, // [286]:0b1111111111111111101000
|
|
1542
|
+
{.value = 228, .offset = {0, 0}}, // [287]:0b1111111111111111101001
|
|
1543
|
+
{.value = -1, .offset = {1, 2}}, // [288]
|
|
1544
|
+
{.value = 232, .offset = {0, 0}}, // [289]:0b1111111111111111101010
|
|
1545
|
+
{.value = 233, .offset = {0, 0}}, // [290]:0b1111111111111111101011
|
|
1546
|
+
{.value = -1, .offset = {1, 8}}, // [291]
|
|
1547
|
+
{.value = -1, .offset = {1, 4}}, // [292]
|
|
1548
|
+
{.value = -1, .offset = {1, 2}}, // [293]
|
|
1549
|
+
{.value = 1, .offset = {0, 0}}, // [294]:0b11111111111111111011000
|
|
1550
|
+
{.value = 135, .offset = {0, 0}}, // [295]:0b11111111111111111011001
|
|
1551
|
+
{.value = -1, .offset = {1, 2}}, // [296]
|
|
1552
|
+
{.value = 137, .offset = {0, 0}}, // [297]:0b11111111111111111011010
|
|
1553
|
+
{.value = 138, .offset = {0, 0}}, // [298]:0b11111111111111111011011
|
|
1554
|
+
{.value = -1, .offset = {1, 4}}, // [299]
|
|
1555
|
+
{.value = -1, .offset = {1, 2}}, // [300]
|
|
1556
|
+
{.value = 139, .offset = {0, 0}}, // [301]:0b11111111111111111011100
|
|
1557
|
+
{.value = 140, .offset = {0, 0}}, // [302]:0b11111111111111111011101
|
|
1558
|
+
{.value = -1, .offset = {1, 2}}, // [303]
|
|
1559
|
+
{.value = 141, .offset = {0, 0}}, // [304]:0b11111111111111111011110
|
|
1560
|
+
{.value = 143, .offset = {0, 0}}, // [305]:0b11111111111111111011111
|
|
1561
|
+
{.value = -1, .offset = {1, 32}}, // [306]
|
|
1562
|
+
{.value = -1, .offset = {1, 16}}, // [307]
|
|
1563
|
+
{.value = -1, .offset = {1, 8}}, // [308]
|
|
1564
|
+
{.value = -1, .offset = {1, 4}}, // [309]
|
|
1565
|
+
{.value = -1, .offset = {1, 2}}, // [310]
|
|
1566
|
+
{.value = 147, .offset = {0, 0}}, // [311]:0b11111111111111111100000
|
|
1567
|
+
{.value = 149, .offset = {0, 0}}, // [312]:0b11111111111111111100001
|
|
1568
|
+
{.value = -1, .offset = {1, 2}}, // [313]
|
|
1569
|
+
{.value = 150, .offset = {0, 0}}, // [314]:0b11111111111111111100010
|
|
1570
|
+
{.value = 151, .offset = {0, 0}}, // [315]:0b11111111111111111100011
|
|
1571
|
+
{.value = -1, .offset = {1, 4}}, // [316]
|
|
1572
|
+
{.value = -1, .offset = {1, 2}}, // [317]
|
|
1573
|
+
{.value = 152, .offset = {0, 0}}, // [318]:0b11111111111111111100100
|
|
1574
|
+
{.value = 155, .offset = {0, 0}}, // [319]:0b11111111111111111100101
|
|
1575
|
+
{.value = -1, .offset = {1, 2}}, // [320]
|
|
1576
|
+
{.value = 157, .offset = {0, 0}}, // [321]:0b11111111111111111100110
|
|
1577
|
+
{.value = 158, .offset = {0, 0}}, // [322]:0b11111111111111111100111
|
|
1578
|
+
{.value = -1, .offset = {1, 8}}, // [323]
|
|
1579
|
+
{.value = -1, .offset = {1, 4}}, // [324]
|
|
1580
|
+
{.value = -1, .offset = {1, 2}}, // [325]
|
|
1581
|
+
{.value = 165, .offset = {0, 0}}, // [326]:0b11111111111111111101000
|
|
1582
|
+
{.value = 166, .offset = {0, 0}}, // [327]:0b11111111111111111101001
|
|
1583
|
+
{.value = -1, .offset = {1, 2}}, // [328]
|
|
1584
|
+
{.value = 168, .offset = {0, 0}}, // [329]:0b11111111111111111101010
|
|
1585
|
+
{.value = 174, .offset = {0, 0}}, // [330]:0b11111111111111111101011
|
|
1586
|
+
{.value = -1, .offset = {1, 4}}, // [331]
|
|
1587
|
+
{.value = -1, .offset = {1, 2}}, // [332]
|
|
1588
|
+
{.value = 175, .offset = {0, 0}}, // [333]:0b11111111111111111101100
|
|
1589
|
+
{.value = 180, .offset = {0, 0}}, // [334]:0b11111111111111111101101
|
|
1590
|
+
{.value = -1, .offset = {1, 2}}, // [335]
|
|
1591
|
+
{.value = 182, .offset = {0, 0}}, // [336]:0b11111111111111111101110
|
|
1592
|
+
{.value = 183, .offset = {0, 0}}, // [337]:0b11111111111111111101111
|
|
1593
|
+
{.value = -1, .offset = {1, 22}}, // [338]
|
|
1594
|
+
{.value = -1, .offset = {1, 8}}, // [339]
|
|
1595
|
+
{.value = -1, .offset = {1, 4}}, // [340]
|
|
1596
|
+
{.value = -1, .offset = {1, 2}}, // [341]
|
|
1597
|
+
{.value = 188, .offset = {0, 0}}, // [342]:0b11111111111111111110000
|
|
1598
|
+
{.value = 191, .offset = {0, 0}}, // [343]:0b11111111111111111110001
|
|
1599
|
+
{.value = -1, .offset = {1, 2}}, // [344]
|
|
1600
|
+
{.value = 197, .offset = {0, 0}}, // [345]:0b11111111111111111110010
|
|
1601
|
+
{.value = 231, .offset = {0, 0}}, // [346]:0b11111111111111111110011
|
|
1602
|
+
{.value = -1, .offset = {1, 6}}, // [347]
|
|
1603
|
+
{.value = -1, .offset = {1, 2}}, // [348]
|
|
1604
|
+
{.value = 239, .offset = {0, 0}}, // [349]:0b11111111111111111110100
|
|
1605
|
+
{.value = -1, .offset = {1, 2}}, // [350]
|
|
1606
|
+
{.value = 9, .offset = {0, 0}}, // [351]:0b111111111111111111101010
|
|
1607
|
+
{.value = 142, .offset = {0, 0}}, // [352]:0b111111111111111111101011
|
|
1608
|
+
{.value = -1, .offset = {1, 4}}, // [353]
|
|
1609
|
+
{.value = -1, .offset = {1, 2}}, // [354]
|
|
1610
|
+
{.value = 144, .offset = {0, 0}}, // [355]:0b111111111111111111101100
|
|
1611
|
+
{.value = 145, .offset = {0, 0}}, // [356]:0b111111111111111111101101
|
|
1612
|
+
{.value = -1, .offset = {1, 2}}, // [357]
|
|
1613
|
+
{.value = 148, .offset = {0, 0}}, // [358]:0b111111111111111111101110
|
|
1614
|
+
{.value = 159, .offset = {0, 0}}, // [359]:0b111111111111111111101111
|
|
1615
|
+
{.value = -1, .offset = {1, 20}}, // [360]
|
|
1616
|
+
{.value = -1, .offset = {1, 8}}, // [361]
|
|
1617
|
+
{.value = -1, .offset = {1, 4}}, // [362]
|
|
1618
|
+
{.value = -1, .offset = {1, 2}}, // [363]
|
|
1619
|
+
{.value = 171, .offset = {0, 0}}, // [364]:0b111111111111111111110000
|
|
1620
|
+
{.value = 206, .offset = {0, 0}}, // [365]:0b111111111111111111110001
|
|
1621
|
+
{.value = -1, .offset = {1, 2}}, // [366]
|
|
1622
|
+
{.value = 215, .offset = {0, 0}}, // [367]:0b111111111111111111110010
|
|
1623
|
+
{.value = 225, .offset = {0, 0}}, // [368]:0b111111111111111111110011
|
|
1624
|
+
{.value = -1, .offset = {1, 4}}, // [369]
|
|
1625
|
+
{.value = -1, .offset = {1, 2}}, // [370]
|
|
1626
|
+
{.value = 236, .offset = {0, 0}}, // [371]:0b111111111111111111110100
|
|
1627
|
+
{.value = 237, .offset = {0, 0}}, // [372]:0b111111111111111111110101
|
|
1628
|
+
{.value = -1, .offset = {1, 4}}, // [373]
|
|
1629
|
+
{.value = -1, .offset = {1, 2}}, // [374]
|
|
1630
|
+
{.value = 199, .offset = {0, 0}}, // [375]:0b1111111111111111111101100
|
|
1631
|
+
{.value = 207, .offset = {0, 0}}, // [376]:0b1111111111111111111101101
|
|
1632
|
+
{.value = -1, .offset = {1, 2}}, // [377]
|
|
1633
|
+
{.value = 234, .offset = {0, 0}}, // [378]:0b1111111111111111111101110
|
|
1634
|
+
{.value = 235, .offset = {0, 0}}, // [379]:0b1111111111111111111101111
|
|
1635
|
+
{.value = -1, .offset = {1, 34}}, // [380]
|
|
1636
|
+
{.value = -1, .offset = {1, 16}}, // [381]
|
|
1637
|
+
{.value = -1, .offset = {1, 8}}, // [382]
|
|
1638
|
+
{.value = -1, .offset = {1, 4}}, // [383]
|
|
1639
|
+
{.value = -1, .offset = {1, 2}}, // [384]
|
|
1640
|
+
{.value = 192, .offset = {0, 0}}, // [385]:0b11111111111111111111100000
|
|
1641
|
+
{.value = 193, .offset = {0, 0}}, // [386]:0b11111111111111111111100001
|
|
1642
|
+
{.value = -1, .offset = {1, 2}}, // [387]
|
|
1643
|
+
{.value = 200, .offset = {0, 0}}, // [388]:0b11111111111111111111100010
|
|
1644
|
+
{.value = 201, .offset = {0, 0}}, // [389]:0b11111111111111111111100011
|
|
1645
|
+
{.value = -1, .offset = {1, 4}}, // [390]
|
|
1646
|
+
{.value = -1, .offset = {1, 2}}, // [391]
|
|
1647
|
+
{.value = 202, .offset = {0, 0}}, // [392]:0b11111111111111111111100100
|
|
1648
|
+
{.value = 205, .offset = {0, 0}}, // [393]:0b11111111111111111111100101
|
|
1649
|
+
{.value = -1, .offset = {1, 2}}, // [394]
|
|
1650
|
+
{.value = 210, .offset = {0, 0}}, // [395]:0b11111111111111111111100110
|
|
1651
|
+
{.value = 213, .offset = {0, 0}}, // [396]:0b11111111111111111111100111
|
|
1652
|
+
{.value = -1, .offset = {1, 8}}, // [397]
|
|
1653
|
+
{.value = -1, .offset = {1, 4}}, // [398]
|
|
1654
|
+
{.value = -1, .offset = {1, 2}}, // [399]
|
|
1655
|
+
{.value = 218, .offset = {0, 0}}, // [400]:0b11111111111111111111101000
|
|
1656
|
+
{.value = 219, .offset = {0, 0}}, // [401]:0b11111111111111111111101001
|
|
1657
|
+
{.value = -1, .offset = {1, 2}}, // [402]
|
|
1658
|
+
{.value = 238, .offset = {0, 0}}, // [403]:0b11111111111111111111101010
|
|
1659
|
+
{.value = 240, .offset = {0, 0}}, // [404]:0b11111111111111111111101011
|
|
1660
|
+
{.value = -1, .offset = {1, 4}}, // [405]
|
|
1661
|
+
{.value = -1, .offset = {1, 2}}, // [406]
|
|
1662
|
+
{.value = 242, .offset = {0, 0}}, // [407]:0b11111111111111111111101100
|
|
1663
|
+
{.value = 243, .offset = {0, 0}}, // [408]:0b11111111111111111111101101
|
|
1664
|
+
{.value = -1, .offset = {1, 2}}, // [409]
|
|
1665
|
+
{.value = 255, .offset = {0, 0}}, // [410]:0b11111111111111111111101110
|
|
1666
|
+
{.value = -1, .offset = {1, 2}}, // [411]
|
|
1667
|
+
{.value = 203, .offset = {0, 0}}, // [412]:0b111111111111111111111011110
|
|
1668
|
+
{.value = 204, .offset = {0, 0}}, // [413]:0b111111111111111111111011111
|
|
1669
|
+
{.value = -1, .offset = {1, 32}}, // [414]
|
|
1670
|
+
{.value = -1, .offset = {1, 16}}, // [415]
|
|
1671
|
+
{.value = -1, .offset = {1, 8}}, // [416]
|
|
1672
|
+
{.value = -1, .offset = {1, 4}}, // [417]
|
|
1673
|
+
{.value = -1, .offset = {1, 2}}, // [418]
|
|
1674
|
+
{.value = 211, .offset = {0, 0}}, // [419]:0b111111111111111111111100000
|
|
1675
|
+
{.value = 212, .offset = {0, 0}}, // [420]:0b111111111111111111111100001
|
|
1676
|
+
{.value = -1, .offset = {1, 2}}, // [421]
|
|
1677
|
+
{.value = 214, .offset = {0, 0}}, // [422]:0b111111111111111111111100010
|
|
1678
|
+
{.value = 221, .offset = {0, 0}}, // [423]:0b111111111111111111111100011
|
|
1679
|
+
{.value = -1, .offset = {1, 4}}, // [424]
|
|
1680
|
+
{.value = -1, .offset = {1, 2}}, // [425]
|
|
1681
|
+
{.value = 222, .offset = {0, 0}}, // [426]:0b111111111111111111111100100
|
|
1682
|
+
{.value = 223, .offset = {0, 0}}, // [427]:0b111111111111111111111100101
|
|
1683
|
+
{.value = -1, .offset = {1, 2}}, // [428]
|
|
1684
|
+
{.value = 241, .offset = {0, 0}}, // [429]:0b111111111111111111111100110
|
|
1685
|
+
{.value = 244, .offset = {0, 0}}, // [430]:0b111111111111111111111100111
|
|
1686
|
+
{.value = -1, .offset = {1, 8}}, // [431]
|
|
1687
|
+
{.value = -1, .offset = {1, 4}}, // [432]
|
|
1688
|
+
{.value = -1, .offset = {1, 2}}, // [433]
|
|
1689
|
+
{.value = 245, .offset = {0, 0}}, // [434]:0b111111111111111111111101000
|
|
1690
|
+
{.value = 246, .offset = {0, 0}}, // [435]:0b111111111111111111111101001
|
|
1691
|
+
{.value = -1, .offset = {1, 2}}, // [436]
|
|
1692
|
+
{.value = 247, .offset = {0, 0}}, // [437]:0b111111111111111111111101010
|
|
1693
|
+
{.value = 248, .offset = {0, 0}}, // [438]:0b111111111111111111111101011
|
|
1694
|
+
{.value = -1, .offset = {1, 4}}, // [439]
|
|
1695
|
+
{.value = -1, .offset = {1, 2}}, // [440]
|
|
1696
|
+
{.value = 250, .offset = {0, 0}}, // [441]:0b111111111111111111111101100
|
|
1697
|
+
{.value = 251, .offset = {0, 0}}, // [442]:0b111111111111111111111101101
|
|
1698
|
+
{.value = -1, .offset = {1, 2}}, // [443]
|
|
1699
|
+
{.value = 252, .offset = {0, 0}}, // [444]:0b111111111111111111111101110
|
|
1700
|
+
{.value = 253, .offset = {0, 0}}, // [445]:0b111111111111111111111101111
|
|
1701
|
+
{.value = -1, .offset = {1, 30}}, // [446]
|
|
1702
|
+
{.value = -1, .offset = {1, 14}}, // [447]
|
|
1703
|
+
{.value = -1, .offset = {1, 6}}, // [448]
|
|
1704
|
+
{.value = -1, .offset = {1, 2}}, // [449]
|
|
1705
|
+
{.value = 254, .offset = {0, 0}}, // [450]:0b111111111111111111111110000
|
|
1706
|
+
{.value = -1, .offset = {1, 2}}, // [451]
|
|
1707
|
+
{.value = 2, .offset = {0, 0}}, // [452]:0b1111111111111111111111100010
|
|
1708
|
+
{.value = 3, .offset = {0, 0}}, // [453]:0b1111111111111111111111100011
|
|
1709
|
+
{.value = -1, .offset = {1, 4}}, // [454]
|
|
1710
|
+
{.value = -1, .offset = {1, 2}}, // [455]
|
|
1711
|
+
{.value = 4, .offset = {0, 0}}, // [456]:0b1111111111111111111111100100
|
|
1712
|
+
{.value = 5, .offset = {0, 0}}, // [457]:0b1111111111111111111111100101
|
|
1713
|
+
{.value = -1, .offset = {1, 2}}, // [458]
|
|
1714
|
+
{.value = 6, .offset = {0, 0}}, // [459]:0b1111111111111111111111100110
|
|
1715
|
+
{.value = 7, .offset = {0, 0}}, // [460]:0b1111111111111111111111100111
|
|
1716
|
+
{.value = -1, .offset = {1, 8}}, // [461]
|
|
1717
|
+
{.value = -1, .offset = {1, 4}}, // [462]
|
|
1718
|
+
{.value = -1, .offset = {1, 2}}, // [463]
|
|
1719
|
+
{.value = 8, .offset = {0, 0}}, // [464]:0b1111111111111111111111101000
|
|
1720
|
+
{.value = 11, .offset = {0, 0}}, // [465]:0b1111111111111111111111101001
|
|
1721
|
+
{.value = -1, .offset = {1, 2}}, // [466]
|
|
1722
|
+
{.value = 12, .offset = {0, 0}}, // [467]:0b1111111111111111111111101010
|
|
1723
|
+
{.value = 14, .offset = {0, 0}}, // [468]:0b1111111111111111111111101011
|
|
1724
|
+
{.value = -1, .offset = {1, 4}}, // [469]
|
|
1725
|
+
{.value = -1, .offset = {1, 2}}, // [470]
|
|
1726
|
+
{.value = 15, .offset = {0, 0}}, // [471]:0b1111111111111111111111101100
|
|
1727
|
+
{.value = 16, .offset = {0, 0}}, // [472]:0b1111111111111111111111101101
|
|
1728
|
+
{.value = -1, .offset = {1, 2}}, // [473]
|
|
1729
|
+
{.value = 17, .offset = {0, 0}}, // [474]:0b1111111111111111111111101110
|
|
1730
|
+
{.value = 18, .offset = {0, 0}}, // [475]:0b1111111111111111111111101111
|
|
1731
|
+
{.value = -1, .offset = {1, 16}}, // [476]
|
|
1732
|
+
{.value = -1, .offset = {1, 8}}, // [477]
|
|
1733
|
+
{.value = -1, .offset = {1, 4}}, // [478]
|
|
1734
|
+
{.value = -1, .offset = {1, 2}}, // [479]
|
|
1735
|
+
{.value = 19, .offset = {0, 0}}, // [480]:0b1111111111111111111111110000
|
|
1736
|
+
{.value = 20, .offset = {0, 0}}, // [481]:0b1111111111111111111111110001
|
|
1737
|
+
{.value = -1, .offset = {1, 2}}, // [482]
|
|
1738
|
+
{.value = 21, .offset = {0, 0}}, // [483]:0b1111111111111111111111110010
|
|
1739
|
+
{.value = 23, .offset = {0, 0}}, // [484]:0b1111111111111111111111110011
|
|
1740
|
+
{.value = -1, .offset = {1, 4}}, // [485]
|
|
1741
|
+
{.value = -1, .offset = {1, 2}}, // [486]
|
|
1742
|
+
{.value = 24, .offset = {0, 0}}, // [487]:0b1111111111111111111111110100
|
|
1743
|
+
{.value = 25, .offset = {0, 0}}, // [488]:0b1111111111111111111111110101
|
|
1744
|
+
{.value = -1, .offset = {1, 2}}, // [489]
|
|
1745
|
+
{.value = 26, .offset = {0, 0}}, // [490]:0b1111111111111111111111110110
|
|
1746
|
+
{.value = 27, .offset = {0, 0}}, // [491]:0b1111111111111111111111110111
|
|
1747
|
+
{.value = -1, .offset = {1, 8}}, // [492]
|
|
1748
|
+
{.value = -1, .offset = {1, 4}}, // [493]
|
|
1749
|
+
{.value = -1, .offset = {1, 2}}, // [494]
|
|
1750
|
+
{.value = 28, .offset = {0, 0}}, // [495]:0b1111111111111111111111111000
|
|
1751
|
+
{.value = 29, .offset = {0, 0}}, // [496]:0b1111111111111111111111111001
|
|
1752
|
+
{.value = -1, .offset = {1, 2}}, // [497]
|
|
1753
|
+
{.value = 30, .offset = {0, 0}}, // [498]:0b1111111111111111111111111010
|
|
1754
|
+
{.value = 31, .offset = {0, 0}}, // [499]:0b1111111111111111111111111011
|
|
1755
|
+
{.value = -1, .offset = {1, 4}}, // [500]
|
|
1756
|
+
{.value = -1, .offset = {1, 2}}, // [501]
|
|
1757
|
+
{.value = 127, .offset = {0, 0}}, // [502]:0b1111111111111111111111111100
|
|
1758
|
+
{.value = 220, .offset = {0, 0}}, // [503]:0b1111111111111111111111111101
|
|
1759
|
+
{.value = -1, .offset = {1, 2}}, // [504]
|
|
1760
|
+
{.value = 249, .offset = {0, 0}}, // [505]:0b1111111111111111111111111110
|
|
1761
|
+
{.value = -1, .offset = {1, 4}}, // [506]
|
|
1762
|
+
{.value = -1, .offset = {1, 2}}, // [507]
|
|
1763
|
+
{.value = 10, .offset = {0, 0}}, // [508]:0b111111111111111111111111111100
|
|
1764
|
+
{.value = 13, .offset = {0, 0}}, // [509]:0b111111111111111111111111111101
|
|
1765
|
+
{.value = -1, .offset = {1, 2}}, // [510]
|
|
1766
|
+
{.value = 22, .offset = {0, 0}}, // [511]:0b111111111111111111111111111110
|
|
1767
|
+
{.value = 256, .offset = {0, 0}}, // [512]:0b111111111111111111111111111111
|
|
1768
|
+
};
|
|
1769
|
+
|
|
1770
|
+
/* *****************************************************************************
|
|
1771
|
+
Don't overwrite after this
|
|
1772
|
+
*****************************************************************************
|
|
1773
|
+
*/
|
|
1774
|
+
|
|
1775
|
+
#endif /* H_HPACK_H */
|