xref: /aosp_15_r20/external/grpc-grpc/test/cpp/microbenchmarks/huffman_geometries/decode_huff_7_12_11.h (revision cc02d7e222339f7a4f6ba5f422e6413f4bd931f2)
1 // Copyright 2023 gRPC authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 // This file is autogenerated: see
16 // tools/codegen/core/gen_huffman_decompressor.cc
17 
18 #ifndef GRPC_TEST_CPP_MICROBENCHMARKS_HUFFMAN_GEOMETRIES_DECODE_HUFF_7_12_11_H
19 #define GRPC_TEST_CPP_MICROBENCHMARKS_HUFFMAN_GEOMETRIES_DECODE_HUFF_7_12_11_H
20 #include <cstddef>
21 #include <cstdint>
22 
23 #include <grpc/support/port_platform.h>
24 namespace grpc_core {
25 namespace geometry_7_12_11 {
26 class HuffDecoderCommon {
27  protected:
GetOp2(size_t i)28   static inline uint64_t GetOp2(size_t i) { return table2_0_ops_[i]; }
GetEmit2(size_t,size_t emit)29   static inline uint64_t GetEmit2(size_t, size_t emit) {
30     return table2_0_emit_[emit];
31   }
GetOp3(size_t i)32   static inline uint64_t GetOp3(size_t i) { return table3_0_ops_[i]; }
GetEmit3(size_t,size_t emit)33   static inline uint64_t GetEmit3(size_t, size_t emit) {
34     return table3_0_emit_[emit];
35   }
GetOp1(size_t i)36   static inline uint64_t GetOp1(size_t i) {
37     return table1_0_inner_[table1_0_outer_[i]];
38   }
GetEmit1(size_t,size_t emit)39   static inline uint64_t GetEmit1(size_t, size_t emit) {
40     return table1_0_emit_[emit];
41   }
GetOp4(size_t i)42   static inline uint64_t GetOp4(size_t i) { return i ? 3 : 1; }
GetEmit4(size_t,size_t emit)43   static inline uint64_t GetEmit4(size_t, size_t emit) {
44     return emit ? 42 : 38;
45   }
GetOp5(size_t i)46   static inline uint64_t GetOp5(size_t i) { return i ? 3 : 1; }
GetEmit5(size_t,size_t emit)47   static inline uint64_t GetEmit5(size_t, size_t emit) {
48     return emit ? 59 : 44;
49   }
GetOp6(size_t i)50   static inline uint64_t GetOp6(size_t i) { return i ? 3 : 1; }
GetEmit6(size_t,size_t emit)51   static inline uint64_t GetEmit6(size_t, size_t emit) {
52     return emit ? 90 : 88;
53   }
GetOp8(size_t i)54   static inline uint64_t GetOp8(size_t i) {
55     return table8_0_inner_[(i < 6 ? (i) : ((i - 6) + 5))];
56   }
GetEmit8(size_t,size_t emit)57   static inline uint64_t GetEmit8(size_t, size_t emit) {
58     return table8_0_emit_[emit];
59   }
GetOp9(size_t i)60   static inline uint64_t GetOp9(size_t i) {
61     return table9_0_inner_[table9_0_outer_[i]];
62   }
GetEmit9(size_t,size_t emit)63   static inline uint64_t GetEmit9(size_t, size_t emit) {
64     return table9_0_emit_[emit];
65   }
GetOp10(size_t i)66   static inline uint64_t GetOp10(size_t i) { return table10_0_ops_[i]; }
GetEmit10(size_t,size_t emit)67   static inline uint64_t GetEmit10(size_t, size_t emit) {
68     return table10_0_emit_[emit];
69   }
GetOp11(size_t i)70   static inline uint64_t GetOp11(size_t i) { return table11_0_ops_[i]; }
GetEmit11(size_t,size_t emit)71   static inline uint64_t GetEmit11(size_t, size_t emit) {
72     return table11_0_emit_[emit];
73   }
GetOp12(size_t i)74   static inline uint64_t GetOp12(size_t i) { return table12_0_ops_[i]; }
GetEmit12(size_t,size_t emit)75   static inline uint64_t GetEmit12(size_t, size_t emit) {
76     return table12_0_emit_[emit];
77   }
GetOp13(size_t i)78   static inline uint64_t GetOp13(size_t i) {
79     return table13_ops_[i >> 6][i & 0x3f];
80   }
GetEmit13(size_t i,size_t emit)81   static inline uint64_t GetEmit13(size_t i, size_t emit) {
82     return table13_emit_[i >> 6][emit];
83   }
GetOp14(size_t i)84   static inline uint64_t GetOp14(size_t i) {
85     return table14_ops_[i >> 6][i & 0x3f];
86   }
GetEmit14(size_t i,size_t emit)87   static inline uint64_t GetEmit14(size_t i, size_t emit) {
88     return table14_emit_[i >> 6][emit];
89   }
GetOp15(size_t i)90   static inline uint64_t GetOp15(size_t i) {
91     return table15_ops_[i >> 6][i & 0x3f];
92   }
GetEmit15(size_t i,size_t emit)93   static inline uint64_t GetEmit15(size_t i, size_t emit) {
94     return table15_emit_[i >> 6][emit];
95   }
GetOp16(size_t i)96   static inline uint64_t GetOp16(size_t i) {
97     return table16_ops_[i >> 6][i & 0x3f];
98   }
GetEmit16(size_t i,size_t emit)99   static inline uint64_t GetEmit16(size_t i, size_t emit) {
100     return table16_emit_[i >> 6][emit];
101   }
GetOp7(size_t i)102   static inline uint64_t GetOp7(size_t i) {
103     return table7_ops_[i >> 7][i & 0x7f];
104   }
GetEmit7(size_t i,size_t emit)105   static inline uint64_t GetEmit7(size_t i, size_t emit) {
106     return table7_emit_[i >> 7][emit];
107   }
GetOp17(size_t i)108   static inline uint64_t GetOp17(size_t i) { return i ? 3 : 1; }
GetEmit17(size_t,size_t emit)109   static inline uint64_t GetEmit17(size_t, size_t emit) {
110     return emit ? 130 : 128;
111   }
GetOp18(size_t i)112   static inline uint64_t GetOp18(size_t i) { return i ? 3 : 1; }
GetEmit18(size_t,size_t emit)113   static inline uint64_t GetEmit18(size_t, size_t emit) {
114     return emit ? 162 : 131;
115   }
GetOp19(size_t i)116   static inline uint64_t GetOp19(size_t i) { return i ? 3 : 1; }
GetEmit19(size_t,size_t emit)117   static inline uint64_t GetEmit19(size_t, size_t emit) {
118     return emit ? 194 : 184;
119   }
GetOp20(size_t i)120   static inline uint64_t GetOp20(size_t i) { return i ? 3 : 1; }
GetEmit20(size_t,size_t emit)121   static inline uint64_t GetEmit20(size_t, size_t emit) {
122     return emit ? 226 : 224;
123   }
GetOp21(size_t i)124   static inline uint64_t GetOp21(size_t i) {
125     return (i < 2 ? (i ? 6 : 2) : ((i - 2) ? 14 : 10));
126   }
GetEmit21(size_t,size_t emit)127   static inline uint64_t GetEmit21(size_t, size_t emit) {
128     return (emit < 2 ? (emit ? 161 : 153) : ((emit - 2) ? 172 : 167));
129   }
GetOp22(size_t i)130   static inline uint64_t GetOp22(size_t i) {
131     return (i < 2 ? (i ? 6 : 2) : ((i - 2) ? 14 : 10));
132   }
GetEmit22(size_t,size_t emit)133   static inline uint64_t GetEmit22(size_t, size_t emit) {
134     return (emit < 2 ? (emit + 176) : ((emit - 2) ? 209 : 179));
135   }
GetOp23(size_t i)136   static inline uint64_t GetOp23(size_t i) {
137     return (i < 2 ? (i ? 6 : 2) : ((i - 2) ? 14 : 10));
138   }
GetEmit23(size_t,size_t emit)139   static inline uint64_t GetEmit23(size_t, size_t emit) {
140     return (emit < 2 ? (emit + 216) : ((emit - 2) ? 229 : 227));
141   }
GetOp24(size_t i)142   static inline uint64_t GetOp24(size_t i) { return table24_0_inner_[i]; }
GetEmit24(size_t,size_t emit)143   static inline uint64_t GetEmit24(size_t, size_t emit) {
144     return table24_0_emit_[emit];
145   }
GetOp25(size_t i)146   static inline uint64_t GetOp25(size_t i) { return table24_0_inner_[i]; }
GetEmit25(size_t,size_t emit)147   static inline uint64_t GetEmit25(size_t, size_t emit) {
148     return table25_0_emit_[emit];
149   }
GetOp26(size_t i)150   static inline uint64_t GetOp26(size_t i) { return table26_0_inner_[i]; }
GetEmit26(size_t,size_t emit)151   static inline uint64_t GetEmit26(size_t, size_t emit) {
152     return table26_0_emit_[emit];
153   }
GetOp28(size_t i)154   static inline uint64_t GetOp28(size_t i) {
155     return (i < 1 ? (((void)i, 0)) : (((void)(i - 1), 1)));
156   }
GetEmit28(size_t,size_t emit)157   static inline uint64_t GetEmit28(size_t, size_t emit) {
158     return ((void)emit, 230);
159   }
GetOp27(size_t i)160   static inline uint64_t GetOp27(size_t i) {
161     return table27_0_inner_[(i < 1 ? (((void)i, 0)) : ((i - 1)))];
162   }
GetEmit27(size_t,size_t emit)163   static inline uint64_t GetEmit27(size_t, size_t emit) {
164     return table27_0_emit_[emit];
165   }
GetOp30(size_t i)166   static inline uint64_t GetOp30(size_t i) {
167     return table30_0_inner_[(i < 4 ? (i) : (((void)(i - 4), 4)))];
168   }
GetEmit30(size_t,size_t emit)169   static inline uint64_t GetEmit30(size_t, size_t emit) {
170     return (emit < 2 ? (emit ? 228 : 198) : ((emit - 2) + 232));
171   }
GetOp29(size_t i)172   static inline uint64_t GetOp29(size_t i) {
173     return table29_0_inner_[(i < 7 ? (i / 2 + 0) : ((i - 7) + 3))];
174   }
GetEmit29(size_t,size_t emit)175   static inline uint64_t GetEmit29(size_t, size_t emit) {
176     return table29_0_emit_[emit];
177   }
GetOp32(size_t i)178   static inline uint64_t GetOp32(size_t i) {
179     return table8_0_inner_[(i < 5 ? (i) : ((i - 5) / 10 + 5))];
180   }
GetEmit32(size_t,size_t emit)181   static inline uint64_t GetEmit32(size_t, size_t emit) {
182     return table32_0_emit_[emit];
183   }
GetOp33(size_t i)184   static inline uint64_t GetOp33(size_t i) { return table33_0_ops_[i]; }
GetEmit33(size_t,size_t emit)185   static inline uint64_t GetEmit33(size_t, size_t emit) {
186     return table33_0_emit_[emit];
187   }
GetOp34(size_t i)188   static inline uint64_t GetOp34(size_t i) { return table34_0_ops_[i]; }
GetEmit34(size_t,size_t emit)189   static inline uint64_t GetEmit34(size_t, size_t emit) {
190     return table34_0_emit_[emit];
191   }
GetOp35(size_t i)192   static inline uint64_t GetOp35(size_t i) { return table35_0_ops_[i]; }
GetEmit35(size_t,size_t emit)193   static inline uint64_t GetEmit35(size_t, size_t emit) {
194     return table35_0_emit_[emit];
195   }
GetOp36(size_t i)196   static inline uint64_t GetOp36(size_t i) { return table36_0_ops_[i]; }
GetEmit36(size_t,size_t emit)197   static inline uint64_t GetEmit36(size_t, size_t emit) {
198     return table36_0_emit_[emit];
199   }
GetOp37(size_t i)200   static inline uint64_t GetOp37(size_t i) {
201     return table37_ops_[i >> 6][i & 0x3f];
202   }
GetEmit37(size_t i,size_t emit)203   static inline uint64_t GetEmit37(size_t i, size_t emit) {
204     return table37_emit_[i >> 6][emit];
205   }
GetOp38(size_t i)206   static inline uint64_t GetOp38(size_t i) {
207     return table38_ops_[i >> 6][i & 0x3f];
208   }
GetEmit38(size_t i,size_t emit)209   static inline uint64_t GetEmit38(size_t i, size_t emit) {
210     return table38_emit_[i >> 6][emit];
211   }
GetOp31(size_t i)212   static inline uint64_t GetOp31(size_t i) {
213     return table31_ops_[i >> 6][i & 0x3f];
214   }
GetEmit31(size_t i,size_t emit)215   static inline uint64_t GetEmit31(size_t i, size_t emit) {
216     return table31_emit_[i >> 6][emit];
217   }
218 
219  private:
220   static const uint8_t table2_0_emit_[10];
221   static const uint8_t table2_0_ops_[32];
222   static const uint8_t table3_0_emit_[36];
223   static const uint8_t table3_0_ops_[64];
224   static const uint8_t table1_0_emit_[68];
225   static const uint16_t table1_0_inner_[72];
226   static const uint8_t table1_0_outer_[128];
227   static const uint8_t table8_0_emit_[5];
228   static const uint8_t table8_0_inner_[7];
229   static const uint8_t table9_0_emit_[8];
230   static const uint8_t table9_0_inner_[10];
231   static const uint8_t table9_0_outer_[16];
232   static const uint8_t table10_0_emit_[10];
233   static const uint8_t table10_0_ops_[32];
234   static const uint8_t table11_0_emit_[16];
235   static const uint8_t table11_0_ops_[64];
236   static const uint8_t table12_0_emit_[18];
237   static const uint8_t table12_0_ops_[128];
238   static const uint8_t table13_0_emit_[40];
239   static const uint8_t table13_0_ops_[64];
240   static const uint8_t table13_1_emit_[40];
241   static const uint8_t table13_2_emit_[22];
242   static const uint8_t table13_2_ops_[64];
243   static const uint8_t table13_3_emit_[14];
244   static const uint8_t table13_3_ops_[64];
245   static const uint8_t* const table13_emit_[4];
246   static const uint8_t* const table13_ops_[4];
247   static const uint8_t table14_0_emit_[72];
248   static const uint16_t table14_0_ops_[64];
249   static const uint8_t table14_1_emit_[72];
250   static const uint8_t table14_2_emit_[72];
251   static const uint8_t table14_3_emit_[72];
252   static const uint8_t table14_4_emit_[72];
253   static const uint8_t table14_5_emit_[40];
254   static const uint16_t table14_5_ops_[64];
255   static const uint8_t table14_6_emit_[22];
256   static const uint16_t table14_6_ops_[64];
257   static const uint8_t table14_7_emit_[11];
258   static const uint16_t table14_7_ops_[64];
259   static const uint8_t* const table14_emit_[8];
260   static const uint16_t* const table14_ops_[8];
261   static const uint8_t table15_0_emit_[44];
262   static const uint16_t table15_0_ops_[64];
263   static const uint8_t table15_1_emit_[92];
264   static const uint16_t table15_1_ops_[64];
265   static const uint8_t table15_2_emit_[44];
266   static const uint8_t table15_3_emit_[92];
267   static const uint8_t table15_4_emit_[44];
268   static const uint8_t table15_5_emit_[92];
269   static const uint8_t table15_6_emit_[44];
270   static const uint8_t table15_7_emit_[92];
271   static const uint8_t table15_8_emit_[44];
272   static const uint8_t table15_9_emit_[92];
273   static const uint8_t table15_10_emit_[72];
274   static const uint8_t table15_11_emit_[72];
275   static const uint8_t table15_12_emit_[72];
276   static const uint8_t table15_13_emit_[40];
277   static const uint8_t table15_14_emit_[4];
278   static const uint16_t table15_14_ops_[64];
279   static const uint8_t table15_15_emit_[7];
280   static const uint16_t table15_15_ops_[64];
281   static const uint8_t* const table15_emit_[16];
282   static const uint16_t* const table15_ops_[16];
283   static const uint8_t table16_0_emit_[16];
284   static const uint16_t table16_0_ops_[64];
285   static const uint8_t table16_1_emit_[28];
286   static const uint16_t table16_1_ops_[64];
287   static const uint8_t table16_2_emit_[36];
288   static const uint16_t table16_2_ops_[64];
289   static const uint8_t table16_3_emit_[68];
290   static const uint16_t table16_3_ops_[64];
291   static const uint8_t table16_4_emit_[16];
292   static const uint8_t table16_5_emit_[28];
293   static const uint8_t table16_6_emit_[36];
294   static const uint8_t table16_7_emit_[68];
295   static const uint8_t table16_8_emit_[16];
296   static const uint8_t table16_9_emit_[28];
297   static const uint8_t table16_10_emit_[36];
298   static const uint8_t table16_11_emit_[68];
299   static const uint8_t table16_12_emit_[16];
300   static const uint8_t table16_13_emit_[28];
301   static const uint8_t table16_14_emit_[36];
302   static const uint8_t table16_15_emit_[68];
303   static const uint8_t table16_16_emit_[16];
304   static const uint8_t table16_17_emit_[28];
305   static const uint8_t table16_18_emit_[36];
306   static const uint8_t table16_19_emit_[68];
307   static const uint8_t table16_20_emit_[44];
308   static const uint8_t table16_21_emit_[92];
309   static const uint8_t table16_22_emit_[44];
310   static const uint8_t table16_23_emit_[92];
311   static const uint8_t table16_24_emit_[44];
312   static const uint8_t table16_25_emit_[92];
313   static const uint8_t table16_26_emit_[72];
314   static const uint8_t table16_27_emit_[72];
315   static const uint8_t table16_28_emit_[40];
316   static const uint8_t table16_29_emit_[40];
317   static const uint8_t table16_30_emit_[40];
318   static const uint8_t table16_31_emit_[5];
319   static const uint16_t table16_31_ops_[64];
320   static const uint8_t* const table16_emit_[32];
321   static const uint16_t* const table16_ops_[32];
322   static const uint8_t table7_0_emit_[1];
323   static const uint16_t table7_0_ops_[128];
324   static const uint8_t table7_4_emit_[1];
325   static const uint8_t table7_8_emit_[1];
326   static const uint8_t table7_12_emit_[1];
327   static const uint8_t table7_16_emit_[1];
328   static const uint8_t table7_20_emit_[1];
329   static const uint16_t table7_20_ops_[128];
330   static const uint8_t table7_22_emit_[1];
331   static const uint8_t table7_24_emit_[1];
332   static const uint8_t table7_26_emit_[1];
333   static const uint16_t table7_26_ops_[128];
334   static const uint8_t table7_27_emit_[1];
335   static const uint8_t table7_28_emit_[2];
336   static const uint16_t table7_28_ops_[128];
337   static const uint8_t table7_29_emit_[2];
338   static const uint8_t table7_30_emit_[2];
339   static const uint8_t table7_31_emit_[8];
340   static const uint16_t table7_31_ops_[128];
341   static const uint8_t* const table7_emit_[32];
342   static const uint16_t* const table7_ops_[32];
343   static const uint8_t table24_0_emit_[8];
344   static const uint8_t table24_0_inner_[8];
345   static const uint8_t table25_0_emit_[8];
346   static const uint8_t table26_0_emit_[16];
347   static const uint8_t table26_0_inner_[16];
348   static const uint8_t table27_0_emit_[7];
349   static const uint8_t table27_0_inner_[7];
350   static const uint8_t table30_0_inner_[5];
351   static const uint8_t table29_0_emit_[12];
352   static const uint8_t table29_0_inner_[12];
353   static const uint8_t table32_0_emit_[5];
354   static const uint8_t table33_0_emit_[17];
355   static const uint8_t table33_0_ops_[32];
356   static const uint8_t table34_0_emit_[21];
357   static const uint8_t table34_0_ops_[64];
358   static const uint8_t table35_0_emit_[36];
359   static const uint8_t table35_0_ops_[128];
360   static const uint8_t table36_0_emit_[55];
361   static const uint8_t table36_0_ops_[256];
362   static const uint8_t table37_0_emit_[40];
363   static const uint8_t table37_1_emit_[40];
364   static const uint8_t table37_2_emit_[22];
365   static const uint8_t table37_3_emit_[4];
366   static const uint8_t table37_3_ops_[64];
367   static const uint8_t table37_4_emit_[4];
368   static const uint8_t table37_5_emit_[6];
369   static const uint8_t table37_5_ops_[64];
370   static const uint8_t table37_6_emit_[17];
371   static const uint8_t table37_6_ops_[64];
372   static const uint8_t table37_7_emit_[46];
373   static const uint8_t table37_7_ops_[64];
374   static const uint8_t* const table37_emit_[8];
375   static const uint8_t* const table37_ops_[8];
376   static const uint8_t table38_0_emit_[72];
377   static const uint8_t table38_1_emit_[72];
378   static const uint8_t table38_2_emit_[72];
379   static const uint8_t table38_3_emit_[72];
380   static const uint8_t table38_4_emit_[72];
381   static const uint8_t table38_5_emit_[40];
382   static const uint8_t table38_6_emit_[40];
383   static const uint8_t table38_7_emit_[40];
384   static const uint8_t table38_8_emit_[40];
385   static const uint8_t table38_9_emit_[40];
386   static const uint8_t table38_10_emit_[40];
387   static const uint8_t table38_11_emit_[4];
388   static const uint8_t table38_12_emit_[8];
389   static const uint16_t table38_12_ops_[64];
390   static const uint8_t table38_13_emit_[9];
391   static const uint16_t table38_13_ops_[64];
392   static const uint8_t table38_14_emit_[16];
393   static const uint16_t table38_14_ops_[64];
394   static const uint8_t table38_15_emit_[30];
395   static const uint16_t table38_15_ops_[64];
396   static const uint8_t* const table38_emit_[16];
397   static const uint16_t* const table38_ops_[16];
398   static const uint8_t table31_0_emit_[1];
399   static const uint16_t table31_0_ops_[64];
400   static const uint8_t table31_2_emit_[1];
401   static const uint8_t table31_4_emit_[1];
402   static const uint8_t table31_6_emit_[1];
403   static const uint8_t table31_8_emit_[1];
404   static const uint8_t table31_10_emit_[1];
405   static const uint16_t table31_10_ops_[64];
406   static const uint8_t table31_11_emit_[1];
407   static const uint8_t table31_12_emit_[1];
408   static const uint8_t table31_13_emit_[1];
409   static const uint8_t table31_14_emit_[1];
410   static const uint8_t table31_15_emit_[1];
411   static const uint8_t table31_16_emit_[1];
412   static const uint8_t table31_17_emit_[1];
413   static const uint8_t table31_18_emit_[1];
414   static const uint8_t table31_19_emit_[1];
415   static const uint8_t table31_20_emit_[1];
416   static const uint8_t table31_21_emit_[1];
417   static const uint8_t table31_22_emit_[2];
418   static const uint16_t table31_22_ops_[64];
419   static const uint8_t table31_23_emit_[2];
420   static const uint8_t table31_24_emit_[4];
421   static const uint16_t table31_24_ops_[64];
422   static const uint8_t table31_25_emit_[4];
423   static const uint8_t table31_26_emit_[4];
424   static const uint8_t table31_27_emit_[5];
425   static const uint16_t table31_27_ops_[64];
426   static const uint8_t table31_28_emit_[8];
427   static const uint16_t table31_28_ops_[64];
428   static const uint8_t table31_29_emit_[8];
429   static const uint8_t table31_30_emit_[15];
430   static const uint16_t table31_30_ops_[64];
431   static const uint8_t table31_31_emit_[18];
432   static const uint16_t table31_31_ops_[64];
433   static const uint8_t* const table31_emit_[32];
434   static const uint16_t* const table31_ops_[32];
435 };
436 template <typename F>
437 class HuffDecoder : public HuffDecoderCommon {
438  public:
HuffDecoder(F sink,const uint8_t * begin,const uint8_t * end)439   HuffDecoder(F sink, const uint8_t* begin, const uint8_t* end)
440       : sink_(sink), begin_(begin), end_(end) {}
Run()441   bool Run() {
442     while (!done_) {
443       if (!RefillTo7()) {
444         Done0();
445         break;
446       }
447       const auto index = (buffer_ >> (buffer_len_ - 7)) & 0x7f;
448       const auto op = GetOp1(index);
449       const int consumed = op & 7;
450       buffer_len_ -= consumed;
451       const auto emit_ofs = op >> 6;
452       switch ((op >> 3) & 7) {
453         case 0: {
454           sink_(GetEmit1(index, emit_ofs + 0));
455           break;
456         }
457         case 1: {
458           DecodeStep0();
459           break;
460         }
461         case 2: {
462           DecodeStep1();
463           break;
464         }
465         case 3: {
466           DecodeStep2();
467           break;
468         }
469         case 4: {
470           DecodeStep3();
471           break;
472         }
473       }
474     }
475     return ok_;
476   }
477 
478  private:
RefillTo7()479   bool RefillTo7() {
480     switch (buffer_len_) {
481       case 0: {
482         return Read1to8Bytes();
483       }
484       case 1:
485       case 2:
486       case 3:
487       case 4:
488       case 5:
489       case 6: {
490         return Read1to7Bytes();
491       }
492     }
493     return true;
494   }
Read1to8Bytes()495   bool Read1to8Bytes() {
496     switch (end_ - begin_) {
497       case 0: {
498         return false;
499       }
500       case 1: {
501         Fill1();
502         return true;
503       }
504       case 2: {
505         Fill2();
506         return true;
507       }
508       case 3: {
509         Fill3();
510         return true;
511       }
512       case 4: {
513         Fill4();
514         return true;
515       }
516       case 5: {
517         Fill5();
518         return true;
519       }
520       case 6: {
521         Fill6();
522         return true;
523       }
524       case 7: {
525         Fill7();
526         return true;
527       }
528       default: {
529         Fill8();
530         return true;
531       }
532     }
533   }
Fill1()534   void Fill1() {
535     buffer_ = (buffer_ << 8) | (static_cast<uint64_t>(begin_[0]) << 0);
536     begin_ += 1;
537     buffer_len_ += 8;
538   }
Fill2()539   void Fill2() {
540     buffer_ = (buffer_ << 16) | (static_cast<uint64_t>(begin_[0]) << 8) |
541               (static_cast<uint64_t>(begin_[1]) << 0);
542     begin_ += 2;
543     buffer_len_ += 16;
544   }
Fill3()545   void Fill3() {
546     buffer_ = (buffer_ << 24) | (static_cast<uint64_t>(begin_[0]) << 16) |
547               (static_cast<uint64_t>(begin_[1]) << 8) |
548               (static_cast<uint64_t>(begin_[2]) << 0);
549     begin_ += 3;
550     buffer_len_ += 24;
551   }
Fill4()552   void Fill4() {
553     buffer_ = (buffer_ << 32) | (static_cast<uint64_t>(begin_[0]) << 24) |
554               (static_cast<uint64_t>(begin_[1]) << 16) |
555               (static_cast<uint64_t>(begin_[2]) << 8) |
556               (static_cast<uint64_t>(begin_[3]) << 0);
557     begin_ += 4;
558     buffer_len_ += 32;
559   }
Fill5()560   void Fill5() {
561     buffer_ = (buffer_ << 40) | (static_cast<uint64_t>(begin_[0]) << 32) |
562               (static_cast<uint64_t>(begin_[1]) << 24) |
563               (static_cast<uint64_t>(begin_[2]) << 16) |
564               (static_cast<uint64_t>(begin_[3]) << 8) |
565               (static_cast<uint64_t>(begin_[4]) << 0);
566     begin_ += 5;
567     buffer_len_ += 40;
568   }
Fill6()569   void Fill6() {
570     buffer_ = (buffer_ << 48) | (static_cast<uint64_t>(begin_[0]) << 40) |
571               (static_cast<uint64_t>(begin_[1]) << 32) |
572               (static_cast<uint64_t>(begin_[2]) << 24) |
573               (static_cast<uint64_t>(begin_[3]) << 16) |
574               (static_cast<uint64_t>(begin_[4]) << 8) |
575               (static_cast<uint64_t>(begin_[5]) << 0);
576     begin_ += 6;
577     buffer_len_ += 48;
578   }
Fill7()579   void Fill7() {
580     buffer_ = (buffer_ << 56) | (static_cast<uint64_t>(begin_[0]) << 48) |
581               (static_cast<uint64_t>(begin_[1]) << 40) |
582               (static_cast<uint64_t>(begin_[2]) << 32) |
583               (static_cast<uint64_t>(begin_[3]) << 24) |
584               (static_cast<uint64_t>(begin_[4]) << 16) |
585               (static_cast<uint64_t>(begin_[5]) << 8) |
586               (static_cast<uint64_t>(begin_[6]) << 0);
587     begin_ += 7;
588     buffer_len_ += 56;
589   }
Fill8()590   void Fill8() {
591     buffer_ = 0 | (static_cast<uint64_t>(begin_[0]) << 56) |
592               (static_cast<uint64_t>(begin_[1]) << 48) |
593               (static_cast<uint64_t>(begin_[2]) << 40) |
594               (static_cast<uint64_t>(begin_[3]) << 32) |
595               (static_cast<uint64_t>(begin_[4]) << 24) |
596               (static_cast<uint64_t>(begin_[5]) << 16) |
597               (static_cast<uint64_t>(begin_[6]) << 8) |
598               (static_cast<uint64_t>(begin_[7]) << 0);
599     begin_ += 8;
600     buffer_len_ += 64;
601   }
Read1to7Bytes()602   bool Read1to7Bytes() {
603     switch (end_ - begin_) {
604       case 0: {
605         return false;
606       }
607       case 1: {
608         Fill1();
609         return true;
610       }
611       case 2: {
612         Fill2();
613         return true;
614       }
615       case 3: {
616         Fill3();
617         return true;
618       }
619       case 4: {
620         Fill4();
621         return true;
622       }
623       case 5: {
624         Fill5();
625         return true;
626       }
627       case 6: {
628         Fill6();
629         return true;
630       }
631       default: {
632         Fill7();
633         return true;
634       }
635     }
636   }
Done0()637   void Done0() {
638     done_ = true;
639     switch (buffer_len_) {
640       case 1:
641       case 2:
642       case 3:
643       case 4: {
644         ok_ = (buffer_ & ((1 << buffer_len_) - 1)) == (1 << buffer_len_) - 1;
645         return;
646       }
647       case 5: {
648         const auto index = buffer_ & 31;
649         const auto op = GetOp2(index);
650         switch (op & 3) {
651           case 0: {
652             sink_(GetEmit2(index, (op >> 2) + 0));
653             break;
654           }
655           case 1: {
656             ok_ = false;
657             break;
658           }
659         }
660         return;
661       }
662       case 6: {
663         const auto index = buffer_ & 63;
664         const auto op = GetOp3(index);
665         switch (op & 3) {
666           case 0: {
667             ok_ = false;
668             break;
669           }
670           case 1: {
671             sink_(GetEmit3(index, (op >> 2) + 0));
672             break;
673           }
674         }
675         return;
676       }
677       case 0: {
678         return;
679       }
680     }
681   }
DecodeStep0()682   void DecodeStep0() {
683     if (!RefillTo1()) {
684       Done1();
685       return;
686     }
687     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
688     const auto op = GetOp4(index);
689     const int consumed = op & 1;
690     buffer_len_ -= consumed;
691     const auto emit_ofs = op >> 1;
692     sink_(GetEmit4(index, emit_ofs + 0));
693   }
RefillTo1()694   bool RefillTo1() {
695     switch (buffer_len_) {
696       case 0: {
697         return Read1to8Bytes();
698       }
699     }
700     return true;
701   }
Done1()702   void Done1() {
703     done_ = true;
704     ok_ = false;
705   }
DecodeStep1()706   void DecodeStep1() {
707     if (!RefillTo1()) {
708       Done2();
709       return;
710     }
711     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
712     const auto op = GetOp5(index);
713     const int consumed = op & 1;
714     buffer_len_ -= consumed;
715     const auto emit_ofs = op >> 1;
716     sink_(GetEmit5(index, emit_ofs + 0));
717   }
Done2()718   void Done2() {
719     done_ = true;
720     ok_ = false;
721   }
DecodeStep2()722   void DecodeStep2() {
723     if (!RefillTo1()) {
724       Done3();
725       return;
726     }
727     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
728     const auto op = GetOp6(index);
729     const int consumed = op & 1;
730     buffer_len_ -= consumed;
731     const auto emit_ofs = op >> 1;
732     sink_(GetEmit6(index, emit_ofs + 0));
733   }
Done3()734   void Done3() {
735     done_ = true;
736     ok_ = false;
737   }
DecodeStep3()738   void DecodeStep3() {
739     if (!RefillTo12()) {
740       Done4();
741       return;
742     }
743     const auto index = (buffer_ >> (buffer_len_ - 12)) & 0xfff;
744     const auto op = GetOp7(index);
745     const int consumed = op & 15;
746     buffer_len_ -= consumed;
747     const auto emit_ofs = op >> 8;
748     switch ((op >> 4) & 15) {
749       case 0: {
750         sink_(GetEmit7(index, emit_ofs + 0));
751         break;
752       }
753       case 1: {
754         DecodeStep4();
755         break;
756       }
757       case 2: {
758         DecodeStep5();
759         break;
760       }
761       case 3: {
762         DecodeStep6();
763         break;
764       }
765       case 4: {
766         DecodeStep7();
767         break;
768       }
769       case 5: {
770         DecodeStep8();
771         break;
772       }
773       case 6: {
774         DecodeStep9();
775         break;
776       }
777       case 7: {
778         DecodeStep10();
779         break;
780       }
781       case 8: {
782         DecodeStep14();
783         break;
784       }
785       case 9: {
786         DecodeStep11();
787         break;
788       }
789       case 10: {
790         DecodeStep12();
791         break;
792       }
793       case 11: {
794         DecodeStep15();
795         break;
796       }
797       case 12: {
798         DecodeStep13();
799         break;
800       }
801       case 13: {
802         DecodeStep16();
803         break;
804       }
805     }
806   }
RefillTo12()807   bool RefillTo12() {
808     switch (buffer_len_) {
809       case 0: {
810         return Read2to8Bytes();
811       }
812       case 1:
813       case 2:
814       case 3: {
815         return Read2to7Bytes();
816       }
817       case 4:
818       case 5:
819       case 6:
820       case 7:
821       case 8: {
822         return Read1to7Bytes();
823       }
824       case 9:
825       case 10:
826       case 11: {
827         return Read1to6Bytes();
828       }
829     }
830     return true;
831   }
Read2to8Bytes()832   bool Read2to8Bytes() {
833     switch (end_ - begin_) {
834       case 0:
835       case 1: {
836         return false;
837       }
838       case 2: {
839         Fill2();
840         return true;
841       }
842       case 3: {
843         Fill3();
844         return true;
845       }
846       case 4: {
847         Fill4();
848         return true;
849       }
850       case 5: {
851         Fill5();
852         return true;
853       }
854       case 6: {
855         Fill6();
856         return true;
857       }
858       case 7: {
859         Fill7();
860         return true;
861       }
862       default: {
863         Fill8();
864         return true;
865       }
866     }
867   }
Read2to7Bytes()868   bool Read2to7Bytes() {
869     switch (end_ - begin_) {
870       case 0:
871       case 1: {
872         return false;
873       }
874       case 2: {
875         Fill2();
876         return true;
877       }
878       case 3: {
879         Fill3();
880         return true;
881       }
882       case 4: {
883         Fill4();
884         return true;
885       }
886       case 5: {
887         Fill5();
888         return true;
889       }
890       case 6: {
891         Fill6();
892         return true;
893       }
894       default: {
895         Fill7();
896         return true;
897       }
898     }
899   }
Read1to6Bytes()900   bool Read1to6Bytes() {
901     switch (end_ - begin_) {
902       case 0: {
903         return false;
904       }
905       case 1: {
906         Fill1();
907         return true;
908       }
909       case 2: {
910         Fill2();
911         return true;
912       }
913       case 3: {
914         Fill3();
915         return true;
916       }
917       case 4: {
918         Fill4();
919         return true;
920       }
921       case 5: {
922         Fill5();
923         return true;
924       }
925       default: {
926         Fill6();
927         return true;
928       }
929     }
930   }
Done4()931   void Done4() {
932     done_ = true;
933     switch (end_ - begin_) {
934       case 1: {
935         Fill1();
936         break;
937       }
938     }
939     switch (buffer_len_) {
940       case 1:
941       case 2: {
942         ok_ = (buffer_ & ((1 << buffer_len_) - 1)) == (1 << buffer_len_) - 1;
943         return;
944       }
945       case 3: {
946         const auto index = buffer_ & 7;
947         const auto op = GetOp8(index);
948         switch (op & 3) {
949           case 0: {
950             sink_(GetEmit8(index, (op >> 2) + 0));
951             break;
952           }
953           case 1: {
954             ok_ = false;
955             break;
956           }
957         }
958         return;
959       }
960       case 4: {
961         const auto index = buffer_ & 15;
962         const auto op = GetOp9(index);
963         switch (op & 3) {
964           case 0: {
965             ok_ = false;
966             break;
967           }
968           case 1: {
969             sink_(GetEmit9(index, (op >> 2) + 0));
970             break;
971           }
972         }
973         return;
974       }
975       case 5: {
976         const auto index = buffer_ & 31;
977         const auto op = GetOp10(index);
978         switch (op & 3) {
979           case 0: {
980             ok_ = false;
981             break;
982           }
983           case 1: {
984             sink_(GetEmit10(index, (op >> 2) + 0));
985             break;
986           }
987         }
988         return;
989       }
990       case 6: {
991         const auto index = buffer_ & 63;
992         const auto op = GetOp11(index);
993         switch (op & 3) {
994           case 0: {
995             ok_ = false;
996             break;
997           }
998           case 1: {
999             sink_(GetEmit11(index, (op >> 2) + 0));
1000             break;
1001           }
1002         }
1003         return;
1004       }
1005       case 7: {
1006         const auto index = buffer_ & 127;
1007         const auto op = GetOp12(index);
1008         switch (op & 3) {
1009           case 0: {
1010             ok_ = false;
1011             break;
1012           }
1013           case 1: {
1014             sink_(GetEmit12(index, (op >> 2) + 0));
1015             break;
1016           }
1017         }
1018         return;
1019       }
1020       case 8: {
1021         const auto index = buffer_ & 255;
1022         const auto op = GetOp13(index);
1023         switch (op & 3) {
1024           case 0: {
1025             sink_(GetEmit13(index, (op >> 2) + 0));
1026             sink_(GetEmit13(index, (op >> 2) + 1));
1027             break;
1028           }
1029           case 1: {
1030             ok_ = false;
1031             break;
1032           }
1033           case 2: {
1034             sink_(GetEmit13(index, (op >> 2) + 0));
1035             break;
1036           }
1037         }
1038         return;
1039       }
1040       case 9: {
1041         const auto index = buffer_ & 511;
1042         const auto op = GetOp14(index);
1043         switch (op & 3) {
1044           case 0: {
1045             ok_ = false;
1046             break;
1047           }
1048           case 1: {
1049             sink_(GetEmit14(index, (op >> 2) + 0));
1050             sink_(GetEmit14(index, (op >> 2) + 1));
1051             break;
1052           }
1053           case 2: {
1054             sink_(GetEmit14(index, (op >> 2) + 0));
1055             break;
1056           }
1057         }
1058         return;
1059       }
1060       case 10: {
1061         const auto index = buffer_ & 1023;
1062         const auto op = GetOp15(index);
1063         switch (op & 3) {
1064           case 0: {
1065             ok_ = false;
1066             break;
1067           }
1068           case 1: {
1069             sink_(GetEmit15(index, (op >> 2) + 0));
1070             sink_(GetEmit15(index, (op >> 2) + 1));
1071             break;
1072           }
1073           case 2: {
1074             sink_(GetEmit15(index, (op >> 2) + 0));
1075             break;
1076           }
1077         }
1078         return;
1079       }
1080       case 11: {
1081         const auto index = buffer_ & 2047;
1082         const auto op = GetOp16(index);
1083         switch (op & 3) {
1084           case 0: {
1085             ok_ = false;
1086             break;
1087           }
1088           case 1: {
1089             sink_(GetEmit16(index, (op >> 2) + 0));
1090             sink_(GetEmit16(index, (op >> 2) + 1));
1091             break;
1092           }
1093           case 2: {
1094             sink_(GetEmit16(index, (op >> 2) + 0));
1095             break;
1096           }
1097         }
1098         return;
1099       }
1100       case 0: {
1101         return;
1102       }
1103     }
1104   }
DecodeStep4()1105   void DecodeStep4() {
1106     if (!RefillTo1()) {
1107       Done5();
1108       return;
1109     }
1110     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
1111     const auto op = GetOp17(index);
1112     const int consumed = op & 1;
1113     buffer_len_ -= consumed;
1114     const auto emit_ofs = op >> 1;
1115     sink_(GetEmit17(index, emit_ofs + 0));
1116   }
Done5()1117   void Done5() {
1118     done_ = true;
1119     ok_ = false;
1120   }
DecodeStep5()1121   void DecodeStep5() {
1122     if (!RefillTo1()) {
1123       Done6();
1124       return;
1125     }
1126     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
1127     const auto op = GetOp18(index);
1128     const int consumed = op & 1;
1129     buffer_len_ -= consumed;
1130     const auto emit_ofs = op >> 1;
1131     sink_(GetEmit18(index, emit_ofs + 0));
1132   }
Done6()1133   void Done6() {
1134     done_ = true;
1135     ok_ = false;
1136   }
DecodeStep6()1137   void DecodeStep6() {
1138     if (!RefillTo1()) {
1139       Done7();
1140       return;
1141     }
1142     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
1143     const auto op = GetOp19(index);
1144     const int consumed = op & 1;
1145     buffer_len_ -= consumed;
1146     const auto emit_ofs = op >> 1;
1147     sink_(GetEmit19(index, emit_ofs + 0));
1148   }
Done7()1149   void Done7() {
1150     done_ = true;
1151     ok_ = false;
1152   }
DecodeStep7()1153   void DecodeStep7() {
1154     if (!RefillTo1()) {
1155       Done8();
1156       return;
1157     }
1158     const auto index = (buffer_ >> (buffer_len_ - 1)) & 0x1;
1159     const auto op = GetOp20(index);
1160     const int consumed = op & 1;
1161     buffer_len_ -= consumed;
1162     const auto emit_ofs = op >> 1;
1163     sink_(GetEmit20(index, emit_ofs + 0));
1164   }
Done8()1165   void Done8() {
1166     done_ = true;
1167     ok_ = false;
1168   }
DecodeStep8()1169   void DecodeStep8() {
1170     if (!RefillTo2()) {
1171       Done9();
1172       return;
1173     }
1174     const auto index = (buffer_ >> (buffer_len_ - 2)) & 0x3;
1175     const auto op = GetOp21(index);
1176     const int consumed = op & 3;
1177     buffer_len_ -= consumed;
1178     const auto emit_ofs = op >> 2;
1179     sink_(GetEmit21(index, emit_ofs + 0));
1180   }
RefillTo2()1181   bool RefillTo2() {
1182     switch (buffer_len_) {
1183       case 0: {
1184         return Read1to8Bytes();
1185       }
1186       case 1: {
1187         return Read1to7Bytes();
1188       }
1189     }
1190     return true;
1191   }
Done9()1192   void Done9() {
1193     done_ = true;
1194     switch (buffer_len_) {
1195       case 1:
1196       case 0: {
1197         ok_ = false;
1198         return;
1199       }
1200     }
1201   }
DecodeStep9()1202   void DecodeStep9() {
1203     if (!RefillTo2()) {
1204       Done10();
1205       return;
1206     }
1207     const auto index = (buffer_ >> (buffer_len_ - 2)) & 0x3;
1208     const auto op = GetOp22(index);
1209     const int consumed = op & 3;
1210     buffer_len_ -= consumed;
1211     const auto emit_ofs = op >> 2;
1212     sink_(GetEmit22(index, emit_ofs + 0));
1213   }
Done10()1214   void Done10() {
1215     done_ = true;
1216     switch (buffer_len_) {
1217       case 1:
1218       case 0: {
1219         ok_ = false;
1220         return;
1221       }
1222     }
1223   }
DecodeStep10()1224   void DecodeStep10() {
1225     if (!RefillTo2()) {
1226       Done11();
1227       return;
1228     }
1229     const auto index = (buffer_ >> (buffer_len_ - 2)) & 0x3;
1230     const auto op = GetOp23(index);
1231     const int consumed = op & 3;
1232     buffer_len_ -= consumed;
1233     const auto emit_ofs = op >> 2;
1234     sink_(GetEmit23(index, emit_ofs + 0));
1235   }
Done11()1236   void Done11() {
1237     done_ = true;
1238     switch (buffer_len_) {
1239       case 1:
1240       case 0: {
1241         ok_ = false;
1242         return;
1243       }
1244     }
1245   }
DecodeStep11()1246   void DecodeStep11() {
1247     if (!RefillTo3()) {
1248       Done12();
1249       return;
1250     }
1251     const auto index = (buffer_ >> (buffer_len_ - 3)) & 0x7;
1252     const auto op = GetOp24(index);
1253     const int consumed = op & 3;
1254     buffer_len_ -= consumed;
1255     const auto emit_ofs = op >> 2;
1256     sink_(GetEmit24(index, emit_ofs + 0));
1257   }
RefillTo3()1258   bool RefillTo3() {
1259     switch (buffer_len_) {
1260       case 0: {
1261         return Read1to8Bytes();
1262       }
1263       case 1:
1264       case 2: {
1265         return Read1to7Bytes();
1266       }
1267     }
1268     return true;
1269   }
Done12()1270   void Done12() {
1271     done_ = true;
1272     switch (buffer_len_) {
1273       case 1:
1274       case 2:
1275       case 0: {
1276         ok_ = false;
1277         return;
1278       }
1279     }
1280   }
DecodeStep12()1281   void DecodeStep12() {
1282     if (!RefillTo3()) {
1283       Done13();
1284       return;
1285     }
1286     const auto index = (buffer_ >> (buffer_len_ - 3)) & 0x7;
1287     const auto op = GetOp25(index);
1288     const int consumed = op & 3;
1289     buffer_len_ -= consumed;
1290     const auto emit_ofs = op >> 2;
1291     sink_(GetEmit25(index, emit_ofs + 0));
1292   }
Done13()1293   void Done13() {
1294     done_ = true;
1295     switch (buffer_len_) {
1296       case 1:
1297       case 2:
1298       case 0: {
1299         ok_ = false;
1300         return;
1301       }
1302     }
1303   }
DecodeStep13()1304   void DecodeStep13() {
1305     if (!RefillTo4()) {
1306       Done14();
1307       return;
1308     }
1309     const auto index = (buffer_ >> (buffer_len_ - 4)) & 0xf;
1310     const auto op = GetOp26(index);
1311     const int consumed = op & 7;
1312     buffer_len_ -= consumed;
1313     const auto emit_ofs = op >> 3;
1314     sink_(GetEmit26(index, emit_ofs + 0));
1315   }
RefillTo4()1316   bool RefillTo4() {
1317     switch (buffer_len_) {
1318       case 0: {
1319         return Read1to8Bytes();
1320       }
1321       case 1:
1322       case 2:
1323       case 3: {
1324         return Read1to7Bytes();
1325       }
1326     }
1327     return true;
1328   }
Done14()1329   void Done14() {
1330     done_ = true;
1331     switch (buffer_len_) {
1332       case 1:
1333       case 2:
1334       case 3:
1335       case 0: {
1336         ok_ = false;
1337         return;
1338       }
1339     }
1340   }
DecodeStep14()1341   void DecodeStep14() {
1342     if (!RefillTo3()) {
1343       Done15();
1344       return;
1345     }
1346     const auto index = (buffer_ >> (buffer_len_ - 3)) & 0x7;
1347     const auto op = GetOp27(index);
1348     const int consumed = op & 3;
1349     buffer_len_ -= consumed;
1350     const auto emit_ofs = op >> 2;
1351     sink_(GetEmit27(index, emit_ofs + 0));
1352   }
Done15()1353   void Done15() {
1354     done_ = true;
1355     switch (buffer_len_) {
1356       case 1:
1357       case 0: {
1358         ok_ = false;
1359         return;
1360       }
1361       case 2: {
1362         const auto index = buffer_ & 3;
1363         const auto op = GetOp28(index);
1364         switch (op & 1) {
1365           case 0: {
1366             sink_(GetEmit28(index, (op >> 1) + 0));
1367             break;
1368           }
1369           case 1: {
1370             ok_ = false;
1371             break;
1372           }
1373         }
1374         return;
1375       }
1376     }
1377   }
DecodeStep15()1378   void DecodeStep15() {
1379     if (!RefillTo4()) {
1380       Done16();
1381       return;
1382     }
1383     const auto index = (buffer_ >> (buffer_len_ - 4)) & 0xf;
1384     const auto op = GetOp29(index);
1385     const int consumed = op & 7;
1386     buffer_len_ -= consumed;
1387     const auto emit_ofs = op >> 3;
1388     sink_(GetEmit29(index, emit_ofs + 0));
1389   }
Done16()1390   void Done16() {
1391     done_ = true;
1392     switch (buffer_len_) {
1393       case 1:
1394       case 2:
1395       case 0: {
1396         ok_ = false;
1397         return;
1398       }
1399       case 3: {
1400         const auto index = buffer_ & 7;
1401         const auto op = GetOp30(index);
1402         switch (op & 1) {
1403           case 0: {
1404             sink_(GetEmit30(index, (op >> 1) + 0));
1405             break;
1406           }
1407           case 1: {
1408             ok_ = false;
1409             break;
1410           }
1411         }
1412         return;
1413       }
1414     }
1415   }
DecodeStep16()1416   void DecodeStep16() {
1417     if (!RefillTo11()) {
1418       Done17();
1419       return;
1420     }
1421     const auto index = (buffer_ >> (buffer_len_ - 11)) & 0x7ff;
1422     const auto op = GetOp31(index);
1423     const int consumed = op & 15;
1424     buffer_len_ -= consumed;
1425     const auto emit_ofs = op >> 5;
1426     switch ((op >> 4) & 1) {
1427       case 0: {
1428         sink_(GetEmit31(index, emit_ofs + 0));
1429         break;
1430       }
1431       case 1: {
1432         begin_ = end_;
1433         buffer_len_ = 0;
1434         break;
1435       }
1436     }
1437   }
RefillTo11()1438   bool RefillTo11() {
1439     switch (buffer_len_) {
1440       case 0: {
1441         return Read2to8Bytes();
1442       }
1443       case 1:
1444       case 2: {
1445         return Read2to7Bytes();
1446       }
1447       case 3:
1448       case 4:
1449       case 5:
1450       case 6:
1451       case 7:
1452       case 8: {
1453         return Read1to7Bytes();
1454       }
1455       case 9:
1456       case 10: {
1457         return Read1to6Bytes();
1458       }
1459     }
1460     return true;
1461   }
Done17()1462   void Done17() {
1463     done_ = true;
1464     switch (end_ - begin_) {
1465       case 1: {
1466         Fill1();
1467         break;
1468       }
1469     }
1470     switch (buffer_len_) {
1471       case 1:
1472       case 2:
1473       case 3: {
1474         ok_ = (buffer_ & ((1 << buffer_len_) - 1)) == (1 << buffer_len_) - 1;
1475         return;
1476       }
1477       case 4: {
1478         const auto index = buffer_ & 15;
1479         const auto op = GetOp32(index);
1480         switch (op & 3) {
1481           case 0: {
1482             sink_(GetEmit32(index, (op >> 2) + 0));
1483             break;
1484           }
1485           case 1: {
1486             ok_ = false;
1487             break;
1488           }
1489         }
1490         return;
1491       }
1492       case 5: {
1493         const auto index = buffer_ & 31;
1494         const auto op = GetOp33(index);
1495         switch (op & 3) {
1496           case 0: {
1497             ok_ = false;
1498             break;
1499           }
1500           case 1: {
1501             sink_(GetEmit33(index, (op >> 2) + 0));
1502             break;
1503           }
1504         }
1505         return;
1506       }
1507       case 6: {
1508         const auto index = buffer_ & 63;
1509         const auto op = GetOp34(index);
1510         switch (op & 3) {
1511           case 0: {
1512             ok_ = false;
1513             break;
1514           }
1515           case 1: {
1516             sink_(GetEmit34(index, (op >> 2) + 0));
1517             break;
1518           }
1519         }
1520         return;
1521       }
1522       case 7: {
1523         const auto index = buffer_ & 127;
1524         const auto op = GetOp35(index);
1525         switch (op & 3) {
1526           case 0: {
1527             ok_ = false;
1528             break;
1529           }
1530           case 1: {
1531             sink_(GetEmit35(index, (op >> 2) + 0));
1532             break;
1533           }
1534         }
1535         return;
1536       }
1537       case 8: {
1538         const auto index = buffer_ & 255;
1539         const auto op = GetOp36(index);
1540         switch (op & 3) {
1541           case 0: {
1542             ok_ = false;
1543             break;
1544           }
1545           case 1: {
1546             sink_(GetEmit36(index, (op >> 2) + 0));
1547             break;
1548           }
1549         }
1550         return;
1551       }
1552       case 9: {
1553         const auto index = buffer_ & 511;
1554         const auto op = GetOp37(index);
1555         switch (op & 3) {
1556           case 0: {
1557             sink_(GetEmit37(index, (op >> 2) + 0));
1558             sink_(GetEmit37(index, (op >> 2) + 1));
1559             break;
1560           }
1561           case 1: {
1562             ok_ = false;
1563             break;
1564           }
1565           case 2: {
1566             sink_(GetEmit37(index, (op >> 2) + 0));
1567             break;
1568           }
1569         }
1570         return;
1571       }
1572       case 10: {
1573         const auto index = buffer_ & 1023;
1574         const auto op = GetOp38(index);
1575         switch (op & 3) {
1576           case 0: {
1577             ok_ = false;
1578             break;
1579           }
1580           case 1: {
1581             sink_(GetEmit38(index, (op >> 2) + 0));
1582             sink_(GetEmit38(index, (op >> 2) + 1));
1583             break;
1584           }
1585           case 2: {
1586             sink_(GetEmit38(index, (op >> 2) + 0));
1587             break;
1588           }
1589         }
1590         return;
1591       }
1592       case 0: {
1593         return;
1594       }
1595     }
1596   }
1597   F sink_;
1598   const uint8_t* begin_;
1599   const uint8_t* const end_;
1600   uint64_t buffer_ = 0;
1601   int buffer_len_ = 0;
1602   bool ok_ = true;
1603   bool done_ = false;
1604 };
1605 }  // namespace geometry_7_12_11
1606 }  // namespace grpc_core
1607 #endif  // GRPC_TEST_CPP_MICROBENCHMARKS_HUFFMAN_GEOMETRIES_DECODE_HUFF_7_12_11_H
1608