; assembly                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                         | /* balcl_optionvalue.t/none @ 0x49aaa0 */
                                                                                                                                                         | #include <stdint.h>
                                                                                                                                                         |  
    ; (fcn) sym._ZN11BloombergLP4bdlb10VariantImpINS_5bslmf8TypeListIJNS0_13NullableValueIbEENS4_IcEENS4_IiEENS4_IxEENS4_IdEENS4_IN3bsl12basic ()        | int64_t ZN11BloombergLP4bdlb10VariantImpINS_5bslmf8TypeListIJNS0_13NullableValueIbEENS4_IcEENS4_IiEENS4_IxEENS4_IdEENS4_IN3bsl12basic (uint32_t arg3, uint32_t arg2, int64_t arg1) {
                                                                                                                                                         |     int64_t var_8h_2;
                                                                                                                                                         |     int64_t var_10h;
                                                                                                                                                         |     int64_t var_18h_3;
                                                                                                                                                         |     int64_t var_20h_3;
                                                                                                                                                         |     int64_t var_28h_2;
                                                                                                                                                         |     int64_t var_30h_3;
                                                                                                                                                         |     int64_t var_38h_2;
                                                                                                                                                         |     int64_t var_40h;
                                                                                                                                                         |     int64_t var_48h_3;
                                                                                                                                                         |     int64_t var_50h_3;
                                                                                                                                                         |     int64_t var_58h_2;
                                                                                                                                                         |     int64_t var_8h;
                                                                                                                                                         |     int64_t var_18h_2;
                                                                                                                                                         |     int64_t var_20h_2;
                                                                                                                                                         |     int64_t var_30h_2;
                                                                                                                                                         |     int64_t var_38h;
                                                                                                                                                         |     int64_t var_48h_2;
                                                                                                                                                         |     int64_t var_50h_2;
                                                                                                                                                         |     int64_t var_60h_2;
                                                                                                                                                         |     int64_t var_68h;
                                                                                                                                                         |     int64_t var_18h;
                                                                                                                                                         |     int64_t var_20h;
                                                                                                                                                         |     int64_t var_28h;
                                                                                                                                                         |     int64_t var_30h;
                                                                                                                                                         |     int64_t var_48h;
                                                                                                                                                         |     int64_t var_50h;
                                                                                                                                                         |     int64_t var_58h;
                                                                                                                                                         |     int64_t var_60h;
                                                                                                                                                         |     rdx = arg3;
                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                         |     rdi = arg1;
    0x0049aaa0 dec edx                                                                                                                                   |     edx--;
    0x0049aaa2 cmp edx, 0x10                                                                                                                             |     
                                                                                                                                                         |     if (edx <= 0x10) {
    0x0049aaa5 ja 0x49ad47                                                                                                                               |         
    0x0049aaab mov rax, rdi                                                                                                                              |         rax = rdi;
                                                                                                                                                         |         /* switch table (17 cases) at 0x4d7ca8 */
    0x0049aaae jmp qword [rdx*8 + 0x4d7ca8]                                                                                                              |         
    0x0049aab5 mov rsi, qword [rsi]                                                                                                                      |         rsi = *(rsi);
    0x0049aab8 mov dl, byte [rsi + 1]                                                                                                                    |         dl = *((rsi + 1));
    0x0049aabb test dl, dl                                                                                                                               |         
    0x0049aabd setne dil                                                                                                                                 |         dil = (dl != 0) ? 1 : 0;
    0x0049aac1 cmp byte [rax + 1], 0                                                                                                                     |         
    0x0049aac5 setne cl                                                                                                                                  |         cl = (*((rax + 1)) != 0) ? 1 : 0;
    0x0049aac8 xor cl, dil                                                                                                                               |         cl ^= dil;
                                                                                                                                                         |         if (*((rax + 1)) != 0) {
    0x0049aacb je 0x49ac96                                                                                                                               |             
    0x0049aad1 test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049aad3 je 0x49acf6                                                                                                                               |                 goto label_0;
                                                                                                                                                         |             }
    0x0049aad9 mov cl, byte [rsi]                                                                                                                        |             cl = *(rsi);
    0x0049aadb mov byte [rax], cl                                                                                                                        |             *(rax) = cl;
    0x0049aadd mov byte [rax + 1], 1                                                                                                                     |             *((rax + 1)) = 1;
    0x0049aae1 cmp byte [rsi + 1], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 1)) == 0) {
    0x0049aae5 je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049aaeb mov byte [rsi + 1], 0                                                                                                                     |             *((rsi + 1)) = 0;
    0x0049aaef ret                                                                                                                                       |             return rax;
    0x0049aaf0 mov rsi, qword [rsi]                                                                                                                      |             rsi = *(rsi);
    0x0049aaf3 mov dl, byte [rsi + 1]                                                                                                                    |             dl = *((rsi + 1));
    0x0049aaf6 test dl, dl                                                                                                                               |             
    0x0049aaf8 setne dil                                                                                                                                 |             dil = (dl != 0) ? 1 : 0;
    0x0049aafc cmp byte [rax + 1], 0                                                                                                                     |             
    0x0049ab00 setne cl                                                                                                                                  |             cl = (*((rax + 1)) != 0) ? 1 : 0;
    0x0049ab03 xor cl, dil                                                                                                                               |             cl ^= dil;
                                                                                                                                                         |             if (*((rax + 1)) == 0) {
    0x0049ab06 je 0x49ac96                                                                                                                               |                 goto label_2;
                                                                                                                                                         |             }
    0x0049ab0c test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049ab0e je 0x49ad09                                                                                                                               |                 goto label_3;
                                                                                                                                                         |             }
    0x0049ab14 mov cl, byte [rsi]                                                                                                                        |             cl = *(rsi);
    0x0049ab16 mov byte [rax], cl                                                                                                                        |             *(rax) = cl;
    0x0049ab18 mov byte [rax + 1], 1                                                                                                                     |             *((rax + 1)) = 1;
    0x0049ab1c cmp byte [rsi + 1], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 1)) == 0) {
    0x0049ab20 je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049ab26 mov byte [rsi + 1], 0                                                                                                                     |             *((rsi + 1)) = 0;
    0x0049ab2a ret                                                                                                                                       |             return rax;
    0x0049ab2b mov rsi, qword [rsi]                                                                                                                      |             rsi = *(rsi);
    0x0049ab2e mov dl, byte [rsi + 4]                                                                                                                    |             dl = *((rsi + 4));
    0x0049ab31 test dl, dl                                                                                                                               |             
    0x0049ab33 setne dil                                                                                                                                 |             dil = (dl != 0) ? 1 : 0;
    0x0049ab37 cmp byte [rax + 4], 0                                                                                                                     |             
    0x0049ab3b setne cl                                                                                                                                  |             cl = (*((rax + 4)) != 0) ? 1 : 0;
    0x0049ab3e xor cl, dil                                                                                                                               |             cl ^= dil;
                                                                                                                                                         |             if (*((rax + 4)) == 0) {
    0x0049ab41 je 0x49aca7                                                                                                                               |                 goto label_4;
                                                                                                                                                         |             }
    0x0049ab47 test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049ab49 je 0x49ace2                                                                                                                               |                 goto label_5;
                                                                                                                                                         |             }
    0x0049ab4f mov ecx, dword [rsi]                                                                                                                      |             ecx = *(rsi);
    0x0049ab51 mov dword [rax], ecx                                                                                                                      |             *(rax) = ecx;
    0x0049ab53 mov byte [rax + 4], 1                                                                                                                     |             *((rax + 4)) = 1;
    0x0049ab57 cmp byte [rsi + 4], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 4)) == 0) {
    0x0049ab5b je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049ab61 mov byte [rsi + 4], 0                                                                                                                     |             *((rsi + 4)) = 0;
    0x0049ab65 ret                                                                                                                                       |             return rax;
    0x0049ab66 mov rsi, qword [rsi]                                                                                                                      |             rsi = *(rsi);
    0x0049ab69 mov dl, byte [rsi + 8]                                                                                                                    |             dl = *((rsi + 8));
    0x0049ab6c test dl, dl                                                                                                                               |             
    0x0049ab6e setne dil                                                                                                                                 |             dil = (dl != 0) ? 1 : 0;
    0x0049ab72 cmp byte [rax + 8], 0                                                                                                                     |             
    0x0049ab76 setne cl                                                                                                                                  |             cl = (*((rax + 8)) != 0) ? 1 : 0;
    0x0049ab79 xor cl, dil                                                                                                                               |             cl ^= dil;
                                                                                                                                                         |             if (*((rax + 8)) == 0) {
    0x0049ab7c je 0x49acb8                                                                                                                               |                 goto label_6;
                                                                                                                                                         |             }
    0x0049ab82 test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049ab84 je 0x49ad1c                                                                                                                               |                 goto label_7;
                                                                                                                                                         |             }
    0x0049ab8a mov rcx, qword [rsi]                                                                                                                      |             rcx = *(rsi);
    0x0049ab8d mov qword [rax], rcx                                                                                                                      |             *(rax) = rcx;
    0x0049ab90 mov byte [rax + 8], 1                                                                                                                     |             *((rax + 8)) = 1;
    0x0049ab94 cmp byte [rsi + 8], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 8)) == 0) {
    0x0049ab98 je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049ab9e mov byte [rsi + 8], 0                                                                                                                     |             *((rsi + 8)) = 0;
    0x0049aba2 ret                                                                                                                                       |             return rax;
    0x0049aba3 mov rsi, qword [rsi]                                                                                                                      |             rsi = *(rsi);
    0x0049aba6 mov dl, byte [rsi + 8]                                                                                                                    |             dl = *((rsi + 8));
    0x0049aba9 test dl, dl                                                                                                                               |             
    0x0049abab setne dil                                                                                                                                 |             dil = (dl != 0) ? 1 : 0;
    0x0049abaf cmp byte [rax + 8], 0                                                                                                                     |             
    0x0049abb3 setne cl                                                                                                                                  |             cl = (*((rax + 8)) != 0) ? 1 : 0;
    0x0049abb6 xor cl, dil                                                                                                                               |             cl ^= dil;
                                                                                                                                                         |             if (*((rax + 8)) == 0) {
    0x0049abb9 je 0x49accd                                                                                                                               |                 goto label_8;
                                                                                                                                                         |             }
    0x0049abbf test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049abc1 je 0x49ad31                                                                                                                               |                 goto label_9;
                                                                                                                                                         |             }
    0x0049abc7 movsd xmm0, qword [rsi]                                                                                                                   |             xmm0 = *(rsi);
    0x0049abcb movsd qword [rax], xmm0                                                                                                                   |             *(rax) = xmm0;
    0x0049abcf mov byte [rax + 8], 1                                                                                                                     |             *((rax + 8)) = 1;
    0x0049abd3 cmp byte [rsi + 8], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 8)) == 0) {
    0x0049abd7 je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049abdd mov byte [rsi + 8], 0                                                                                                                     |             *((rsi + 8)) = 0;
    0x0049abe1 ret                                                                                                                                       |             return rax;
    0x0049abe2 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049abe5 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049abe8 jmp 0x49ad50                                                                                                                              |             void (*0x49ad50)() ();
    0x0049abed mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049abf0 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049abf3 jmp 0x49b220                                                                                                                              |             void (*0x49b220)() ();
    0x0049abf8 mov rsi, qword [rsi]                                                                                                                      |             rsi = *(rsi);
    0x0049abfb mov dl, byte [rsi + 4]                                                                                                                    |             dl = *((rsi + 4));
    0x0049abfe test dl, dl                                                                                                                               |             
    0x0049ac00 setne dil                                                                                                                                 |             dil = (dl != 0) ? 1 : 0;
    0x0049ac04 cmp byte [rax + 4], 0                                                                                                                     |             
    0x0049ac08 setne cl                                                                                                                                  |             cl = (*((rax + 4)) != 0) ? 1 : 0;
    0x0049ac0b xor cl, dil                                                                                                                               |             cl ^= dil;
                                                                                                                                                         |             if (*((rax + 4)) == 0) {
    0x0049ac0e je 0x49aca7                                                                                                                               |                 goto label_4;
                                                                                                                                                         |             }
    0x0049ac14 test dl, dl                                                                                                                               |             
                                                                                                                                                         |             if (dl == 0) {
    0x0049ac16 je 0x49ace2                                                                                                                               |                 goto label_5;
                                                                                                                                                         |             }
    0x0049ac1c mov ecx, dword [rsi]                                                                                                                      |             ecx = *(rsi);
    0x0049ac1e mov dword [rax], ecx                                                                                                                      |             *(rax) = ecx;
    0x0049ac20 mov byte [rax + 4], 1                                                                                                                     |             *((rax + 4)) = 1;
    0x0049ac24 cmp byte [rsi + 4], 0                                                                                                                     |             
                                                                                                                                                         |             if (*((rsi + 4)) == 0) {
    0x0049ac28 je 0x49ad47                                                                                                                               |                 goto label_1;
                                                                                                                                                         |             }
    0x0049ac2e mov byte [rsi + 4], 0                                                                                                                     |             *((rsi + 4)) = 0;
    0x0049ac32 ret                                                                                                                                       |             return rax;
    0x0049ac33 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac36 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac39 jmp 0x49b480                                                                                                                              |             void (*0x49b480)() ();
    0x0049ac3e mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac41 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac44 jmp 0x49b5c0                                                                                                                              |             void (*0x49b5c0)() ();
    0x0049ac49 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac4c mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac4f jmp 0x49b890                                                                                                                              |             void (*0x49b890)() ();
    0x0049ac54 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac57 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac5a jmp 0x49bb60                                                                                                                              |             void (*0x49bb60)() ();
    0x0049ac5f mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac62 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac65 jmp 0x49be30                                                                                                                              |             void (*0x49be30)() ();
    0x0049ac6a mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac6d mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac70 jmp 0x49c100                                                                                                                              |             void (*0x49c100)() ();
    0x0049ac75 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac78 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac7b jmp 0x49c7e0                                                                                                                              |             void (*0x49c7e0)() ();
    0x0049ac80 mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac83 mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac86 jmp 0x49cd10                                                                                                                              |             void (*0x49cd10)() ();
    0x0049ac8b mov rdi, qword [rsi]                                                                                                                      |             rdi = *(rsi);
    0x0049ac8e mov rsi, rax                                                                                                                              |             rsi = rax;
    0x0049ac91 jmp 0x49d240                                                                                                                              |             void (*0x49d240)() ();
                                                                                                                                                         |         }
                                                                                                                                                         | label_2:
    0x0049ac96 test dl, dl                                                                                                                               |         
                                                                                                                                                         |         if (dl == 0) {
    0x0049ac98 je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049ac9e mov cl, byte [rsi]                                                                                                                        |         cl = *(rsi);
    0x0049aca0 mov dl, byte [rax]                                                                                                                        |         dl = *(rax);
    0x0049aca2 mov byte [rsi], dl                                                                                                                        |         *(rsi) = dl;
    0x0049aca4 mov byte [rax], cl                                                                                                                        |         *(rax) = cl;
    0x0049aca6 ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_4:
    0x0049aca7 test dl, dl                                                                                                                               |         
                                                                                                                                                         |         if (dl == 0) {
    0x0049aca9 je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049acaf mov ecx, dword [rsi]                                                                                                                      |         ecx = *(rsi);
    0x0049acb1 mov edx, dword [rax]                                                                                                                      |         edx = *(rax);
    0x0049acb3 mov dword [rsi], edx                                                                                                                      |         *(rsi) = edx;
    0x0049acb5 mov dword [rax], ecx                                                                                                                      |         *(rax) = ecx;
    0x0049acb7 ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_6:
    0x0049acb8 test dl, dl                                                                                                                               |         
                                                                                                                                                         |         if (dl == 0) {
    0x0049acba je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049acc0 mov rcx, qword [rsi]                                                                                                                      |         rcx = *(rsi);
    0x0049acc3 mov rdx, qword [rax]                                                                                                                      |         rdx = *(rax);
    0x0049acc6 mov qword [rsi], rdx                                                                                                                      |         *(rsi) = rdx;
    0x0049acc9 mov qword [rax], rcx                                                                                                                      |         *(rax) = rcx;
    0x0049accc ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_8:
    0x0049accd test dl, dl                                                                                                                               |         
                                                                                                                                                         |         if (dl == 0) {
    0x0049accf je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049acd1 movsd xmm0, qword [rsi]                                                                                                                   |         xmm0 = *(rsi);
    0x0049acd5 movsd xmm1, qword [rax]                                                                                                                   |         xmm1 = *(rax);
    0x0049acd9 movsd qword [rsi], xmm1                                                                                                                   |         *(rsi) = xmm1;
    0x0049acdd movsd qword [rax], xmm0                                                                                                                   |         *(rax) = xmm0;
    0x0049ace1 ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_5:
    0x0049ace2 mov ecx, dword [rax]                                                                                                                      |         ecx = *(rax);
    0x0049ace4 mov dword [rsi], ecx                                                                                                                      |         *(rsi) = ecx;
    0x0049ace6 mov byte [rsi + 4], 1                                                                                                                     |         *((rsi + 4)) = 1;
    0x0049acea cmp byte [rax + 4], 0                                                                                                                     |         
                                                                                                                                                         |         if (*((rax + 4)) == 0) {
    0x0049acee je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049acf0 mov byte [rax + 4], 0                                                                                                                     |         *((rax + 4)) = 0;
    0x0049acf4 jmp 0x49ad47                                                                                                                              |         goto label_1;
                                                                                                                                                         | label_0:
    0x0049acf6 mov cl, byte [rax]                                                                                                                        |         cl = *(rax);
    0x0049acf8 mov byte [rsi], cl                                                                                                                        |         *(rsi) = cl;
    0x0049acfa mov byte [rsi + 1], 1                                                                                                                     |         *((rsi + 1)) = 1;
    0x0049acfe cmp byte [rax + 1], 0                                                                                                                     |         
                                                                                                                                                         |         if (*((rax + 1)) == 0) {
    0x0049ad02 je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049ad04 mov byte [rax + 1], 0                                                                                                                     |         *((rax + 1)) = 0;
    0x0049ad08 ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_3:
    0x0049ad09 mov cl, byte [rax]                                                                                                                        |         cl = *(rax);
    0x0049ad0b mov byte [rsi], cl                                                                                                                        |         *(rsi) = cl;
    0x0049ad0d mov byte [rsi + 1], 1                                                                                                                     |         *((rsi + 1)) = 1;
    0x0049ad11 cmp byte [rax + 1], 0                                                                                                                     |         
                                                                                                                                                         |         if (*((rax + 1)) == 0) {
    0x0049ad15 je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049ad17 mov byte [rax + 1], 0                                                                                                                     |         *((rax + 1)) = 0;
    0x0049ad1b ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_7:
    0x0049ad1c mov rcx, qword [rax]                                                                                                                      |         rcx = *(rax);
    0x0049ad1f mov qword [rsi], rcx                                                                                                                      |         *(rsi) = rcx;
    0x0049ad22 mov byte [rsi + 8], 1                                                                                                                     |         *((rsi + 8)) = 1;
    0x0049ad26 cmp byte [rax + 8], 0                                                                                                                     |         
                                                                                                                                                         |         if (*((rax + 8)) == 0) {
    0x0049ad2a je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049ad2c mov byte [rax + 8], 0                                                                                                                     |         *((rax + 8)) = 0;
    0x0049ad30 ret                                                                                                                                       |         return rax;
                                                                                                                                                         | label_9:
    0x0049ad31 movsd xmm0, qword [rax]                                                                                                                   |         xmm0 = *(rax);
    0x0049ad35 movsd qword [rsi], xmm0                                                                                                                   |         *(rsi) = xmm0;
    0x0049ad39 mov byte [rsi + 8], 1                                                                                                                     |         *((rsi + 8)) = 1;
    0x0049ad3d cmp byte [rax + 8], 0                                                                                                                     |         
                                                                                                                                                         |         if (*((rax + 8)) == 0) {
    0x0049ad41 je 0x49ad47                                                                                                                               |             goto label_1;
                                                                                                                                                         |         }
    0x0049ad43 mov byte [rax + 8], 0                                                                                                                     |         *((rax + 8)) = 0;
                                                                                                                                                         |     }
                                                                                                                                                         | label_1:
    0x0049ad47 ret                                                                                                                                       |     return rax;
                                                                                                                                                         | }