; assembly                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                             | /* bdlt_fixutil.t/none @ 0x43ae90 */
                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bdlt::FixUtil.generateRaw_char__BloombergLP::bdlt::TimeTz_const__BloombergLP::bdlt::FixUtilConfiguration_const_ ()           | int64_t method_BloombergLP::bdlt::FixUtil_generateRaw_char_BloombergLP::bdlt::TimeTz_const_BloombergLP::bdlt::FixUtilConfiguration_const_ (char * arg3, char * arg2, char * arg1) {
                                                                                                                                                             |     rdx = arg3;
                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                             |     /* BloombergLP::bdlt::FixUtil::generateRaw(char*, BloombergLP::bdlt::TimeTz const&, BloombergLP::bdlt::FixUtilConfiguration const&) */
    0x0043ae90 push rbp                                                                                                                                      |     
    0x0043ae91 push r15                                                                                                                                      |     
    0x0043ae93 push r14                                                                                                                                      |     
    0x0043ae95 push r13                                                                                                                                      |     
    0x0043ae97 push r12                                                                                                                                      |     
    0x0043ae99 push rbx                                                                                                                                      |     
    0x0043ae9a push rax                                                                                                                                      |     
    0x0043ae9b mov r14, rdx                                                                                                                                  |     r14 = rdx;
    0x0043ae9e mov r15, rsi                                                                                                                                  |     r15 = rsi;
    0x0043aea1 mov rbx, rdi                                                                                                                                  |     rbx = rdi;
    0x0043aea4 movabs r12, 0xffffffbfffffffff                                                                                                                |     r12 = 0xffffffbfffffffff;
    0x0043aeae movabs r13, 0x4000000000                                                                                                                      |     r13 = 0x4000000000;
    0x0043aeb8 mov rcx, qword [rsi]                                                                                                                          |     rcx = *(rsi);
    0x0043aebb mov qword [rsp], rcx                                                                                                                          |     *(rsp) = rcx;
    0x0043aebf cmp rcx, r13                                                                                                                                  |     
                                                                                                                                                             |     if (rcx < r13) {
    0x0043aec2 jl 0x43b186                                                                                                                                   |         goto label_5;
                                                                                                                                                             |     }
    0x0043aec8 and rcx, r12                                                                                                                                  |     rcx &= r12;
                                                                                                                                                             | label_0:
    0x0043aecb mov rax, rcx                                                                                                                                  |     rax = rcx;
    0x0043aece or rax, r13                                                                                                                                   |     rax |= r13;
    0x0043aed1 mov qword [rsp], rax                                                                                                                          |     *(rsp) = rax;
    0x0043aed5 cmp rax, r13                                                                                                                                  |     
                                                                                                                                                             |     if (rax < r13) {
    0x0043aed8 jl 0x43b196                                                                                                                                   |         goto label_6;
                                                                                                                                                             |     }
    0x0043aede and rcx, r12                                                                                                                                  |     rcx &= r12;
                                                                                                                                                             | label_1:
    0x0043aee1 movabs rbp, 0x98b5bf2c03e529c5                                                                                                                |     
    0x0043aeeb mov rax, rcx                                                                                                                                  |     rax = rcx;
    0x0043aeee imul rbp                                                                                                                                      |     rdx:rax = rax * rbp;
    0x0043aef1 mov rax, rdx                                                                                                                                  |     rax = rdx;
    0x0043aef4 add rax, rcx                                                                                                                                  |     rax += rcx;
    0x0043aef7 mov rcx, rax                                                                                                                                  |     rcx = rax;
    0x0043aefa shr rcx, 0x3f                                                                                                                                 |     rcx >>= 0x3f;
    0x0043aefe shr rax, 0x1f                                                                                                                                 |     rax >>= 0x1f;
    0x0043af02 add eax, ecx                                                                                                                                  |     eax += ecx;
    0x0043af04 xor edx, edx                                                                                                                                  |     edx = 0;
    0x0043af06 cmp eax, 0x17                                                                                                                                 |     
                                                                                                                                                             |     if (eax <= 0x17) {
    0x0043af09 jg 0x43af31                                                                                                                                   |         
    0x0043af0b mov rcx, qword [rsp]                                                                                                                          |         rcx = *(rsp);
    0x0043af0f cmp rcx, r13                                                                                                                                  |         
                                                                                                                                                             |         if (rcx < r13) {
    0x0043af12 jl 0x43b1ca                                                                                                                                   |             goto label_7;
                                                                                                                                                             |         }
    0x0043af18 and rcx, r12                                                                                                                                  |         rcx &= r12;
                                                                                                                                                             | label_4:
    0x0043af1b mov rax, rcx                                                                                                                                  |         rax = rcx;
    0x0043af1e imul rbp                                                                                                                                      |         rdx:rax = rax * rbp;
    0x0043af21 add rdx, rcx                                                                                                                                  |         rdx += rcx;
    0x0043af24 mov rax, rdx                                                                                                                                  |         rax = rdx;
    0x0043af27 shr rax, 0x3f                                                                                                                                 |         rax >>= 0x3f;
    0x0043af2b shr rdx, 0x1f                                                                                                                                 |         rdx >>= 0x1f;
    0x0043af2f add edx, eax                                                                                                                                  |         edx += eax;
                                                                                                                                                             |     }
    0x0043af31 movsxd rax, edx                                                                                                                               |     rax = (int64_t) edx;
    0x0043af34 imul rcx, rax, 0x66666667                                                                                                                     |     rcx = rax * 0x66666667;
    0x0043af3b mov rdx, rcx                                                                                                                                  |     rdx = rcx;
    0x0043af3e shr rdx, 0x3f                                                                                                                                 |     rdx >>= 0x3f;
    0x0043af42 sar rcx, 0x22                                                                                                                                 |     rcx >>= 0x22;
    0x0043af46 add ecx, edx                                                                                                                                  |     ecx += edx;
    0x0043af48 lea edx, [rcx + rcx]                                                                                                                          |     edx = rcx + rcx;
    0x0043af4b lea edx, [rdx + rdx*4]                                                                                                                        |     edx = rdx * 5;
    0x0043af4e sub eax, edx                                                                                                                                  |     eax -= edx;
    0x0043af50 add al, 0x30                                                                                                                                  |     al += 0x30;
    0x0043af52 mov byte [rbx + 1], al                                                                                                                        |     *((rbx + 1)) = al;
    0x0043af55 movsxd rax, ecx                                                                                                                               |     rax = (int64_t) ecx;
    0x0043af58 imul rcx, rax, 0x66666667                                                                                                                     |     rcx = rax * 0x66666667;
    0x0043af5f mov rdx, rcx                                                                                                                                  |     rdx = rcx;
    0x0043af62 shr rdx, 0x3f                                                                                                                                 |     rdx >>= 0x3f;
    0x0043af66 sar rcx, 0x22                                                                                                                                 |     rcx >>= 0x22;
    0x0043af6a add ecx, edx                                                                                                                                  |     ecx += edx;
    0x0043af6c add ecx, ecx                                                                                                                                  |     ecx += ecx;
    0x0043af6e lea ecx, [rcx + rcx*4]                                                                                                                        |     ecx = rcx * 5;
    0x0043af71 sub eax, ecx                                                                                                                                  |     eax -= ecx;
    0x0043af73 add al, 0x30                                                                                                                                  |     al += 0x30;
    0x0043af75 mov byte [rbx], al                                                                                                                            |     *(rbx) = al;
    0x0043af77 mov byte [rbx + 2], 0x3a                                                                                                                      |     *((rbx + 2)) = 0x3a;
    0x0043af7b mov rcx, qword [rsp]                                                                                                                          |     rcx = *(rsp);
    0x0043af7f cmp rcx, r13                                                                                                                                  |     
                                                                                                                                                             |     if (rcx < r13) {
    0x0043af82 jl 0x43b1a6                                                                                                                                   |         goto label_8;
                                                                                                                                                             |     }
    0x0043af88 mov rdi, rcx                                                                                                                                  |     rdi = rcx;
    0x0043af8b and rdi, r12                                                                                                                                  |     rdi &= r12;
                                                                                                                                                             | label_2:
    0x0043af8e movabs rdx, 0x8f2a633943a6d729                                                                                                                |     rdx = 0x8f2a633943a6d729;
    0x0043af98 mov rax, rdi                                                                                                                                  |     rax = rdi;
    0x0043af9b imul rdx                                                                                                                                      |     rdx:rax = rax * rdx;
    0x0043af9e mov rsi, rdx                                                                                                                                  |     rsi = rdx;
    0x0043afa1 add rsi, rdi                                                                                                                                  |     rsi += rdi;
    0x0043afa4 mov rax, rsi                                                                                                                                  |     rax = rsi;
    0x0043afa7 shr rax, 0x3f                                                                                                                                 |     rax >>= 0x3f;
    0x0043afab sar rsi, 0x19                                                                                                                                 |     rsi >>= 0x19;
    0x0043afaf add rsi, rax                                                                                                                                  |     rsi += rax;
    0x0043afb2 movabs rbp, 0x8888888888888889                                                                                                                |     
    0x0043afbc mov rax, rsi                                                                                                                                  |     rax = rsi;
    0x0043afbf imul rbp                                                                                                                                      |     rdx:rax = rax * rbp;
    0x0043afc2 add rdx, rsi                                                                                                                                  |     rdx += rsi;
    0x0043afc5 mov rax, rdx                                                                                                                                  |     rax = rdx;
    0x0043afc8 shr rax, 0x3f                                                                                                                                 |     rax >>= 0x3f;
    0x0043afcc sar rdx, 5                                                                                                                                    |     rdx >>= 5;
    0x0043afd0 add rdx, rax                                                                                                                                  |     rdx += rax;
    0x0043afd3 imul rax, rdx, 0x3c                                                                                                                           |     rax = rdx * 0x3c;
    0x0043afd7 sub rsi, rax                                                                                                                                  |     rsi -= rax;
    0x0043afda movsx eax, sil                                                                                                                                |     eax = (int32_t) sil;
    0x0043afde imul eax, eax, 0x67                                                                                                                           |     eax *= 0x67;
    0x0043afe1 movzx eax, ax                                                                                                                                 |     eax = (int32_t) ax;
    0x0043afe4 movsx edx, ax                                                                                                                                 |     edx = (int32_t) ax;
    0x0043afe7 shr eax, 0xf                                                                                                                                  |     eax >>= 0xf;
    0x0043afea shr edx, 0xa                                                                                                                                  |     edx >>= 0xa;
    0x0043afed add dl, al                                                                                                                                    |     dl += al;
    0x0043afef movzx eax, dl                                                                                                                                 |     eax = (int32_t) dl;
    0x0043aff2 lea edx, [rax + rax]                                                                                                                          |     edx = rax + rax;
    0x0043aff5 lea edx, [rdx + rdx*4]                                                                                                                        |     edx = rdx * 5;
    0x0043aff8 sub sil, dl                                                                                                                                   |     sil -= dl;
    0x0043affb add sil, 0x30                                                                                                                                 |     sil += 0x30;
    0x0043afff mov byte [rbx + 4], sil                                                                                                                       |     *((rbx + 4)) = sil;
    0x0043b003 movsx edx, al                                                                                                                                 |     edx = (int32_t) al;
    0x0043b006 imul edx, edx, 0x67                                                                                                                           |     edx *= 0x67;
    0x0043b009 movzx esi, dx                                                                                                                                 |     esi = (int32_t) dx;
    0x0043b00c shr edx, 0xa                                                                                                                                  |     edx >>= 0xa;
    0x0043b00f shr esi, 0xf                                                                                                                                  |     esi >>= 0xf;
    0x0043b012 add sil, dl                                                                                                                                   |     sil += dl;
    0x0043b015 movzx edx, sil                                                                                                                                |     edx = (int32_t) sil;
    0x0043b019 add edx, edx                                                                                                                                  |     edx += edx;
    0x0043b01b lea edx, [rdx + rdx*4]                                                                                                                        |     edx = rdx * 5;
    0x0043b01e sub al, dl                                                                                                                                    |     al -= dl;
    0x0043b020 add al, 0x30                                                                                                                                  |     al += 0x30;
    0x0043b022 mov byte [rbx + 3], al                                                                                                                        |     *((rbx + 3)) = al;
    0x0043b025 mov byte [rbx + 5], 0x3a                                                                                                                      |     *((rbx + 5)) = 0x3a;
    0x0043b029 cmp rcx, r13                                                                                                                                  |     
                                                                                                                                                             |     if (rcx < r13) {
    0x0043b02c jl 0x43b1ba                                                                                                                                   |         goto label_9;
                                                                                                                                                             |     }
    0x0043b032 and rcx, r12                                                                                                                                  |     rcx &= r12;
                                                                                                                                                             | label_3:
    0x0043b035 movabs rdx, 0x431bde82d7b634db                                                                                                                |     rdx = 0x431bde82d7b634db;
    0x0043b03f mov rax, rcx                                                                                                                                  |     rax = rcx;
    0x0043b042 imul rdx                                                                                                                                      |     rdx:rax = rax * rdx;
    0x0043b045 mov rcx, rdx                                                                                                                                  |     rcx = rdx;
    0x0043b048 mov rax, rdx                                                                                                                                  |     rax = rdx;
    0x0043b04b shr rax, 0x3f                                                                                                                                 |     rax >>= 0x3f;
    0x0043b04f sar rcx, 0x12                                                                                                                                 |     rcx >>= 0x12;
    0x0043b053 add rcx, rax                                                                                                                                  |     rcx += rax;
    0x0043b056 mov rax, rcx                                                                                                                                  |     rax = rcx;
    0x0043b059 imul rbp                                                                                                                                      |     rdx:rax = rax * rbp;
    0x0043b05c add rdx, rcx                                                                                                                                  |     rdx += rcx;
    0x0043b05f mov rax, rdx                                                                                                                                  |     rax = rdx;
    0x0043b062 shr rax, 0x3f                                                                                                                                 |     rax >>= 0x3f;
    0x0043b066 sar rdx, 5                                                                                                                                    |     rdx >>= 5;
    0x0043b06a add rdx, rax                                                                                                                                  |     rdx += rax;
    0x0043b06d imul rax, rdx, 0x3c                                                                                                                           |     rax = rdx * 0x3c;
    0x0043b071 sub rcx, rax                                                                                                                                  |     rcx -= rax;
    0x0043b074 movsx eax, cl                                                                                                                                 |     eax = (int32_t) cl;
    0x0043b077 imul eax, eax, 0x67                                                                                                                           |     eax *= 0x67;
    0x0043b07a movzx eax, ax                                                                                                                                 |     eax = (int32_t) ax;
    0x0043b07d mov edx, eax                                                                                                                                  |     edx = eax;
    0x0043b07f shr edx, 0xf                                                                                                                                  |     edx >>= 0xf;
    0x0043b082 shr eax, 8                                                                                                                                    |     eax >>= 8;
    0x0043b085 sar al, 2                                                                                                                                     |     al >>= 2;
    0x0043b088 add al, dl                                                                                                                                    |     al += dl;
    0x0043b08a movzx eax, al                                                                                                                                 |     eax = (int32_t) al;
    0x0043b08d lea edx, [rax + rax]                                                                                                                          |     edx = rax + rax;
    0x0043b090 lea edx, [rdx + rdx*4]                                                                                                                        |     edx = rdx * 5;
    0x0043b093 sub cl, dl                                                                                                                                    |     cl -= dl;
    0x0043b095 add cl, 0x30                                                                                                                                  |     cl += 0x30;
    0x0043b098 mov byte [rbx + 7], cl                                                                                                                        |     *((rbx + 7)) = cl;
    0x0043b09b movsx ecx, al                                                                                                                                 |     ecx = (int32_t) al;
    0x0043b09e imul ecx, ecx, 0x67                                                                                                                           |     ecx *= 0x67;
    0x0043b0a1 movzx ecx, cx                                                                                                                                 |     ecx = (int32_t) cx;
    0x0043b0a4 mov edx, ecx                                                                                                                                  |     edx = ecx;
    0x0043b0a6 shr edx, 0xf                                                                                                                                  |     edx >>= 0xf;
    0x0043b0a9 shr ecx, 8                                                                                                                                    |     ecx >>= 8;
    0x0043b0ac sar cl, 2                                                                                                                                     |     cl >>= 2;
    0x0043b0af add cl, dl                                                                                                                                    |     cl += dl;
    0x0043b0b1 movzx ecx, cl                                                                                                                                 |     ecx = (int32_t) cl;
    0x0043b0b4 add ecx, ecx                                                                                                                                  |     ecx += ecx;
    0x0043b0b6 lea ecx, [rcx + rcx*4]                                                                                                                        |     ecx = rcx * 5;
    0x0043b0b9 sub al, cl                                                                                                                                    |     al -= cl;
    0x0043b0bb add al, 0x30                                                                                                                                  |     al += 0x30;
    0x0043b0bd mov byte [rbx + 6], al                                                                                                                        |     *((rbx + 6)) = al;
    0x0043b0c0 lea rax, [rbx + 8]                                                                                                                            |     rax = rbx + 8;
    0x0043b0c4 mov edx, dword [r15 + 8]                                                                                                                      |     edx = *((r15 + 8));
    0x0043b0c8 test edx, edx                                                                                                                                 |     
                                                                                                                                                             |     if (edx == 0) {
    0x0043b0ca jne 0x43b0d6                                                                                                                                  |         
    0x0043b0cc test byte [r14], 8                                                                                                                            |         
                                                                                                                                                             |         if ((*(r14) & 8) != 0) {
    0x0043b0d0 jne 0x43b17c                                                                                                                                  |             goto label_10;
                                                                                                                                                             |         }
                                                                                                                                                             |     }
    0x0043b0d6 mov ecx, edx                                                                                                                                  |     ecx = edx;
    0x0043b0d8 neg ecx                                                                                                                                       |     ecx = -ecx;
                                                                                                                                                             |     if ((*(r14) & 8) < 0) {
    0x0043b0da cmovl ecx, edx                                                                                                                                |         ecx = edx;
                                                                                                                                                             |     }
    0x0043b0dd shr edx, 0x1f                                                                                                                                 |     edx >>= 0x1f;
    0x0043b0e0 add dl, dl                                                                                                                                    |     dl += dl;
    0x0043b0e2 add dl, 0x2b                                                                                                                                  |     dl += 0x2b;
    0x0043b0e5 mov byte [rbx + 8], dl                                                                                                                        |     *((rbx + 8)) = dl;
    0x0043b0e8 mov esi, 0x88888889                                                                                                                           |     esi = 0x88888889;
    0x0043b0ed imul rsi, rcx                                                                                                                                 |     rsi *= rcx;
    0x0043b0f1 shr rsi, 0x25                                                                                                                                 |     rsi >>= 0x25;
    0x0043b0f5 mov edx, 0xcccccccd                                                                                                                           |     edx = 0xcccccccd;
    0x0043b0fa mov edi, esi                                                                                                                                  |     edi = esi;
    0x0043b0fc imul ebp, esi, 0x3c                                                                                                                           |     ebp = esi * 0x3c;
    0x0043b0ff imul rsi, rdx                                                                                                                                 |     rsi *= rdx;
    0x0043b103 shr rsi, 0x23                                                                                                                                 |     rsi >>= 0x23;
    0x0043b107 add esi, esi                                                                                                                                  |     esi += esi;
    0x0043b109 lea esi, [rsi + rsi*4]                                                                                                                        |     esi = rsi * 5;
    0x0043b10c sub edi, esi                                                                                                                                  |     edi -= esi;
    0x0043b10e or dil, 0x30                                                                                                                                  |     dil |= 0x30;
    0x0043b112 mov byte [rbx + 0xa], dil                                                                                                                     |     *((rbx + 0xa)) = dil;
    0x0043b116 imul rsi, rcx, 0x1b4e81b5                                                                                                                     |     rsi = rcx * 0x1b4e81b5;
    0x0043b11d shr rsi, 0x26                                                                                                                                 |     rsi >>= 0x26;
    0x0043b121 mov rdi, rsi                                                                                                                                  |     rdi = rsi;
    0x0043b124 imul rdi, rdx                                                                                                                                 |     rdi *= rdx;
    0x0043b128 shr rdi, 0x23                                                                                                                                 |     rdi >>= 0x23;
    0x0043b12c add edi, edi                                                                                                                                  |     edi += edi;
    0x0043b12e lea edx, [rdi + rdi*4]                                                                                                                        |     edx = rdi * 5;
    0x0043b131 sub esi, edx                                                                                                                                  |     esi -= edx;
    0x0043b133 or sil, 0x30                                                                                                                                  |     sil |= 0x30;
    0x0043b137 mov byte [rbx + 9], sil                                                                                                                       |     *((rbx + 9)) = sil;
    0x0043b13b mov byte [rbx + 0xb], 0x3a                                                                                                                    |     *((rbx + 0xb)) = 0x3a;
    0x0043b13f sub ecx, ebp                                                                                                                                  |     ecx -= ebp;
    0x0043b141 imul edx, ecx, 0xcd                                                                                                                           |     edx = ecx * 0xcd;
    0x0043b147 movzx edx, dx                                                                                                                                 |     edx = (int32_t) dx;
    0x0043b14a shr edx, 0xb                                                                                                                                  |     edx >>= 0xb;
    0x0043b14d lea esi, [rdx + rdx]                                                                                                                          |     esi = rdx + rdx;
    0x0043b150 lea esi, [rsi + rsi*4]                                                                                                                        |     esi = rsi * 5;
    0x0043b153 sub cl, sil                                                                                                                                   |     cl -= sil;
    0x0043b156 or cl, 0x30                                                                                                                                   |     cl |= 0x30;
    0x0043b159 mov byte [rbx + 0xd], cl                                                                                                                      |     *((rbx + 0xd)) = cl;
    0x0043b15c or dl, 0x30                                                                                                                                   |     dl |= 0x30;
    0x0043b15f mov byte [rbx + 0xc], dl                                                                                                                      |     *((rbx + 0xc)) = dl;
    0x0043b162 add rbx, 0xe                                                                                                                                  |     rbx += 0xe;
                                                                                                                                                             |     do {
    0x0043b166 sub ebx, eax                                                                                                                                  |         ebx -= eax;
    0x0043b168 add ebx, 8                                                                                                                                    |         ebx += 8;
    0x0043b16b mov eax, ebx                                                                                                                                  |         eax = ebx;
    0x0043b16d add rsp, 8                                                                                                                                    |         
    0x0043b171 pop rbx                                                                                                                                       |         
    0x0043b172 pop r12                                                                                                                                       |         
    0x0043b174 pop r13                                                                                                                                       |         
    0x0043b176 pop r14                                                                                                                                       |         
    0x0043b178 pop r15                                                                                                                                       |         
    0x0043b17a pop rbp                                                                                                                                       |         
    0x0043b17b ret                                                                                                                                           |         return rax;
                                                                                                                                                             | label_10:
    0x0043b17c mov byte [rbx + 8], 0x5a                                                                                                                      |         *((rbx + 8)) = 0x5a;
    0x0043b180 add rbx, 9                                                                                                                                    |         rbx += 9;
    0x0043b184 jmp 0x43b166                                                                                                                                  |         
                                                                                                                                                             |     } while (1);
                                                                                                                                                             | label_5:
    0x0043b186 mov rdi, rsp                                                                                                                                  |     
    0x0043b189 call 0x43d5c0                                                                                                                                 |     rax = BloombergLP::bdlt::Time::invalidMicrosecondsFromMidnight()const (rsp);
    0x0043b18e mov rcx, rax                                                                                                                                  |     rcx = rax;
    0x0043b191 jmp 0x43aecb                                                                                                                                  |     goto label_0;
                                                                                                                                                             | label_6:
    0x0043b196 mov rdi, rsp                                                                                                                                  |     
    0x0043b199 call 0x43d5c0                                                                                                                                 |     rax = BloombergLP::bdlt::Time::invalidMicrosecondsFromMidnight()const (rsp);
    0x0043b19e mov rcx, rax                                                                                                                                  |     rcx = rax;
    0x0043b1a1 jmp 0x43aee1                                                                                                                                  |     goto label_1;
                                                                                                                                                             | label_8:
    0x0043b1a6 mov rdi, rsp                                                                                                                                  |     
    0x0043b1a9 call 0x43d5c0                                                                                                                                 |     rax = BloombergLP::bdlt::Time::invalidMicrosecondsFromMidnight()const (rsp);
    0x0043b1ae mov rdi, rax                                                                                                                                  |     rdi = rax;
    0x0043b1b1 mov rcx, qword [rsp]                                                                                                                          |     rcx = *(rsp);
    0x0043b1b5 jmp 0x43af8e                                                                                                                                  |     goto label_2;
                                                                                                                                                             | label_9:
    0x0043b1ba mov rdi, rsp                                                                                                                                  |     
    0x0043b1bd call 0x43d5c0                                                                                                                                 |     rax = BloombergLP::bdlt::Time::invalidMicrosecondsFromMidnight()const (rsp);
    0x0043b1c2 mov rcx, rax                                                                                                                                  |     rcx = rax;
    0x0043b1c5 jmp 0x43b035                                                                                                                                  |     goto label_3;
                                                                                                                                                             | label_7:
    0x0043b1ca mov rdi, rsp                                                                                                                                  |     
    0x0043b1cd call 0x43d5c0                                                                                                                                 |     rax = BloombergLP::bdlt::Time::invalidMicrosecondsFromMidnight()const (rsp);
    0x0043b1d2 mov rcx, rax                                                                                                                                  |     rcx = rax;
    0x0043b1d5 jmp 0x43af1b                                                                                                                                  |     goto label_4;
                                                                                                                                                             | }