; assembly                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                     | /* balcl_commandline.t/none @ 0x473000 */
                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlb::TokenizerIterator.TokenizerIterator_char_const__char_const__BloombergLP::bdlb::Tokenizer_Data_const_ ()        | int64_t method_BloombergLP::bdlb::TokenizerIterator_TokenizerIterator_char_const_char_const_BloombergLP::bdlb::Tokenizer_Data_const_ (uint32_t arg4, uint32_t arg3, uint32_t arg2, int64_t arg1) {
                                                                                                                                                     |     rcx = arg4;
                                                                                                                                                     |     rdx = arg3;
                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                     |     /* BloombergLP::bdlb::TokenizerIterator::TokenizerIterator(char const*, char const*, BloombergLP::bdlb::Tokenizer_Data const*) */
    0x00473000 mov qword [rdi], rcx                                                                                                                  |     *(rdi) = rcx;
    0x00473003 mov qword [rdi + 8], rsi                                                                                                              |     *((rdi + 8)) = rsi;
    0x00473007 mov qword [rdi + 0x10], rsi                                                                                                           |     *((rdi + 0x10)) = rsi;
    0x0047300b mov qword [rdi + 0x18], rsi                                                                                                           |     *((rdi + 0x18)) = rsi;
    0x0047300f mov qword [rdi + 0x20], rdx                                                                                                           |     *((rdi + 0x20)) = rdx;
    0x00473013 mov byte [rdi + 0x28], 0                                                                                                              |     *((rdi + 0x28)) = 0;
    0x00473017 test rdx, rdx                                                                                                                         |     
                                                                                                                                                     |     if (rdx == 0) {
    0x0047301a je 0x473052                                                                                                                           |         goto label_2;
                                                                                                                                                     |     }
    0x0047301c cmp rsi, rdx                                                                                                                          |     
                                                                                                                                                     |     if (rsi == rdx) {
    0x0047301f je 0x473144                                                                                                                           |         goto label_3;
                                                                                                                                                     |     }
    0x00473025 nop word cs:[rax + rax]                                                                                                               |     
    0x0047302f nop                                                                                                                                   |     
                                                                                                                                                     |     do {
    0x00473030 movzx eax, byte [rsi]                                                                                                                 |         eax = *(rsi);
    0x00473033 cmp byte [rcx + rax], 1                                                                                                               |         
                                                                                                                                                     |         if (*((rcx + rax)) != 1) {
    0x00473037 jne 0x473048                                                                                                                          |             goto label_4;
                                                                                                                                                     |         }
    0x00473039 inc rsi                                                                                                                               |         rsi++;
    0x0047303c mov qword [rdi + 8], rsi                                                                                                              |         *((rdi + 8)) = rsi;
    0x00473040 cmp rdx, rsi                                                                                                                          |         
    0x00473043 jne 0x473030                                                                                                                          |         
                                                                                                                                                     |     } while (rdx != rsi);
    0x00473045 mov rsi, rdx                                                                                                                          |     rsi = rdx;
                                                                                                                                                     | label_4:
    0x00473048 test rdx, rdx                                                                                                                         |     
                                                                                                                                                     |     if (rdx != 0) {
    0x0047304b jne 0x47307f                                                                                                                          |         goto label_5;
                                                                                                                                                     |     }
    0x0047304d jmp 0x4730e8                                                                                                                          |     goto label_6;
                                                                                                                                                     | label_2:
    0x00473052 mov al, byte [rsi]                                                                                                                    |     al = *(rsi);
    0x00473054 test al, al                                                                                                                           |     
                                                                                                                                                     |     if (al == 0) {
    0x00473056 je 0x4730e8                                                                                                                           |         goto label_6;
                                                                                                                                                     |     }
    0x0047305c inc rsi                                                                                                                               |     rsi++;
    0x0047305f nop                                                                                                                                   |     
                                                                                                                                                     |     do {
    0x00473060 movzx eax, al                                                                                                                         |         eax = (int32_t) al;
    0x00473063 cmp byte [rcx + rax], 1                                                                                                               |         
                                                                                                                                                     |         if (*((rcx + rax)) != 1) {
    0x00473067 jne 0x473077                                                                                                                          |             goto label_7;
                                                                                                                                                     |         }
    0x00473069 mov qword [rdi + 8], rsi                                                                                                              |         *((rdi + 8)) = rsi;
    0x0047306d movzx eax, byte [rsi]                                                                                                                 |         eax = *(rsi);
    0x00473070 inc rsi                                                                                                                               |         rsi++;
    0x00473073 test al, al                                                                                                                           |         
    0x00473075 jne 0x473060                                                                                                                          |         
                                                                                                                                                     |     } while (al != 0);
                                                                                                                                                     | label_7:
    0x00473077 dec rsi                                                                                                                               |     rsi--;
    0x0047307a test rdx, rdx                                                                                                                         |     
                                                                                                                                                     |     if (rdx == 0) {
    0x0047307d je 0x4730e8                                                                                                                           |         goto label_6;
                                                                                                                                                     |     }
                                                                                                                                                     | label_5:
    0x0047307f mov qword [rdi + 0x10], rsi                                                                                                           |     *((rdi + 0x10)) = rsi;
    0x00473083 mov qword [rdi + 0x18], rsi                                                                                                           |     *((rdi + 0x18)) = rsi;
    0x00473087 cmp rsi, rdx                                                                                                                          |     
                                                                                                                                                     |     if (rsi == rdx) {
    0x0047308a je 0x47314c                                                                                                                           |         goto label_8;
                                                                                                                                                     |     }
    0x00473090 xor r8d, r8d                                                                                                                          |     r8d = 0;
    0x00473093 mov r11, rsi                                                                                                                          |     r11 = rsi;
    0x00473096 jmp 0x4730bf                                                                                                                          |     
                                                                                                                                                     |     while (r10d == 0) {
    0x004730a0 inc rsi                                                                                                                               |         rsi++;
    0x004730a3 mov qword [rdi + 0x18], rsi                                                                                                           |         *((rdi + 0x18)) = rsi;
                                                                                                                                                     | label_0:
    0x004730a7 mov r8d, dword [r8 + r9*4 + 0x4b4530]                                                                                                 |         r8d = *((r8 + r9*4 + obj._anonymous_namespace_::stateTable));
    0x004730af inc r11                                                                                                                               |         r11++;
    0x004730b2 mov qword [rdi + 8], r11                                                                                                              |         *((rdi + 8)) = r11;
    0x004730b6 cmp rdx, r11                                                                                                                          |         
                                                                                                                                                     |         if (rdx == r11) {
    0x004730b9 je 0x473143                                                                                                                           |             goto label_9;
                                                                                                                                                     |         }
    0x004730bf movzx eax, byte [r11]                                                                                                                 |         eax = *(r11);
    0x004730c3 movsx rax, byte [rcx + rax]                                                                                                           |         rax = *((rcx + rax));
    0x004730c8 movsxd r8, r8d                                                                                                                        |         r8 = (int64_t) r8d;
    0x004730cb lea r9, [rax + rax*2]                                                                                                                 |         r9 = rax * 3;
    0x004730cf shl r8, 2                                                                                                                             |         r8 <<= 2;
    0x004730d3 mov r10d, dword [r8 + r9*4 + 0x4b4500]                                                                                                |         r10d = *((r8 + r9*4 + obj._anonymous_namespace_::actionTable));
    0x004730db test r10d, r10d                                                                                                                       |         
    0x004730de je 0x4730a0                                                                                                                           |         
                                                                                                                                                     |     }
    0x004730e0 cmp r10d, 2                                                                                                                           |     
                                                                                                                                                     |     if (r10d != 2) {
    0x004730e4 jne 0x4730a7                                                                                                                          |         goto label_0;
                                                                                                                                                     |     }
    0x004730e6 jmp 0x473143                                                                                                                          |     goto label_9;
                                                                                                                                                     | label_6:
    0x004730e8 mov qword [rdi + 0x10], rsi                                                                                                           |     *((rdi + 0x10)) = rsi;
    0x004730ec mov qword [rdi + 0x18], rsi                                                                                                           |     *((rdi + 0x18)) = rsi;
    0x004730f0 mov dl, byte [rsi]                                                                                                                    |     dl = *(rsi);
    0x004730f2 test dl, dl                                                                                                                           |     
                                                                                                                                                     |     if (dl == 0) {
    0x004730f4 je 0x47314c                                                                                                                           |         goto label_8;
                                                                                                                                                     |     }
    0x004730f6 lea rax, [rsi + 1]                                                                                                                    |     rax = rsi + 1;
    0x004730fa xor r8d, r8d                                                                                                                          |     r8d = 0;
    0x004730fd jmp 0x47311d                                                                                                                          |     
                                                                                                                                                     |     while (r9d == 0) {
    0x00473100 inc rsi                                                                                                                               |         rsi++;
    0x00473103 mov qword [rdi + 0x18], rsi                                                                                                           |         *((rdi + 0x18)) = rsi;
                                                                                                                                                     | label_1:
    0x00473107 mov r8d, dword [rdx + r8*4 + 0x4b4530]                                                                                                |         r8d = *((rdx + r8*4 + obj._anonymous_namespace_::stateTable));
    0x0047310f mov qword [rdi + 8], rax                                                                                                              |         *((rdi + 8)) = rax;
    0x00473113 movzx edx, byte [rax]                                                                                                                 |         edx = *(rax);
    0x00473116 inc rax                                                                                                                               |         rax++;
    0x00473119 test dl, dl                                                                                                                           |         
                                                                                                                                                     |         if (dl == 0) {
    0x0047311b je 0x473143                                                                                                                           |             goto label_9;
                                                                                                                                                     |         }
    0x0047311d movzx edx, dl                                                                                                                         |         edx = (int32_t) dl;
    0x00473120 movsx r9, byte [rcx + rdx]                                                                                                            |         r9 = *((rcx + rdx));
    0x00473125 movsxd rdx, r8d                                                                                                                       |         rdx = (int64_t) r8d;
    0x00473128 lea r8, [r9 + r9*2]                                                                                                                   |         r8 = r9 * 3;
    0x0047312c shl rdx, 2                                                                                                                            |         rdx <<= 2;
    0x00473130 mov r9d, dword [rdx + r8*4 + 0x4b4500]                                                                                                |         r9d = *((rdx + r8*4 + obj._anonymous_namespace_::actionTable));
    0x00473138 test r9d, r9d                                                                                                                         |         
    0x0047313b je 0x473100                                                                                                                           |         
                                                                                                                                                     |     }
    0x0047313d cmp r9d, 2                                                                                                                            |     
                                                                                                                                                     |     if (r9d != 2) {
    0x00473141 jne 0x473107                                                                                                                          |         goto label_1;
                                                                                                                                                     |     }
                                                                                                                                                     | label_9:
    0x00473143 ret                                                                                                                                   |     return rax;
                                                                                                                                                     | label_3:
    0x00473144 mov qword [rdi + 0x10], rdx                                                                                                           |     *((rdi + 0x10)) = rdx;
    0x00473148 mov qword [rdi + 0x18], rdx                                                                                                           |     *((rdi + 0x18)) = rdx;
                                                                                                                                                     | label_8:
    0x0047314c mov byte [rdi + 0x28], 1                                                                                                              |     *((rdi + 0x28)) = 1;
    0x00473150 ret                                                                                                                                   |     return rax;
                                                                                                                                                     | }