; assembly | /* r2dec pseudo code output */ | /* bdlde_base64encoder.t/none @ 0x405f80 */ | #include | ; (fcn) sym.isState_BloombergLP::bdlde::Base64Encoder__int_ () | int32_t isState_BloombergLP::bdlde::Base64Encoder_int_ (int64_t arg2, char * arg1) { | uint32_t var_15h; | uint32_t var_16h; | uint32_t var_17h; | uint32_t var_18h; | int64_t var_1fh; | int64_t var_20h; | int64_t var_21h; | int64_t var_22h; | int64_t var_23h; | uint32_t var_28h; | uint32_t var_2ch; | int64_t var_30h; | uint32_t var_34h; | uint32_t var_38h; | uint32_t var_3ch; | uint32_t var_40h; | int64_t var_44h; | rsi = arg2; | rdi = arg1; | /* isState(BloombergLP::bdlde::Base64Encoder*, int) */ 0x00405f80 push rbp | 0x00405f81 push r15 | 0x00405f83 push r14 | 0x00405f85 push r13 | 0x00405f87 push r12 | 0x00405f89 push rbx | 0x00405f8a sub rsp, 0x48 | 0x00405f8e mov ebp, esi | 0x00405f90 mov r14, rdi | r14 = rdi; 0x00405f93 test rdi, rdi | | if (rdi == 0) { 0x00405f96 jne 0x405fc1 | 0x00405f98 mov edi, 0x44f523 | 0x00405f9d mov edx, 0x44d36d | edx = "object"; 0x00405fa2 mov esi, 0x23c | esi = 0x23c; 0x00405fa7 xor eax, eax | eax = 0; 0x00405fa9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405fae mov eax, dword [rip + 0x2629d4] | eax = (anonymous namespace)::testStatus; 0x00405fb4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405fb7 ja 0x405fc1 | goto label_16; | } 0x00405fb9 inc eax | eax++; 0x00405fbb mov dword [rip + 0x2629c7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_16: 0x00405fc1 test ebp, ebp | | if (ebp >= 0) { 0x00405fc3 js 0x405fd6 | 0x00405fc5 cmp ebp, 6 | | if (ebp < 6) { 0x00405fc8 jl 0x405fff | goto label_17; | } 0x00405fca mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405fcf mov edx, 0x44d37f | edx = "state < NUM_STATES"; 0x00405fd4 jmp 0x405fe0 | | } else { 0x00405fd6 mov edi, 0x44f523 | 0x00405fdb mov edx, 0x44d374 | edx = "0 <= state"; | } 0x00405fe0 mov esi, 0x23c | esi = 0x23c; 0x00405fe5 xor eax, eax | eax = 0; 0x00405fe7 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405fec mov eax, dword [rip + 0x262996] | eax = (anonymous namespace)::testStatus; 0x00405ff2 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405ff5 ja 0x405fff | 0x00405ff7 inc eax | eax++; 0x00405ff9 mov dword [rip + 0x262989], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_17: 0x00405fff mov al, byte [rip + 0x26297c] | al = globalAssertsEnabled; 0x00406005 mov byte [rsp + 0x15], al | *((rsp + 0x15)) = al; 0x00406009 mov qword [rsp + 0x20], 0xffffffffffffffff | *((rsp + 0x20)) = 0xffffffffffffffff; 0x00406012 mov dword [rsp + 0x30], 0xffffffff | *((rsp + 0x30)) = 0xffffffff; 0x0040601a mov dword [rsp + 0x44], 0xffffffff | *((rsp + 0x44)) = 0xffffffff; 0x00406022 mov byte [rsp + 0x1f], 0 | *((rsp + 0x1f)) = 0; 0x00406027 cmp ebp, 5 | | if (ebp > 5) { 0x0040602a ja 0x4060ee | goto label_18; | } 0x00406030 mov eax, ebp | eax = ebp; | /* switch table (6 cases) at 0x449c70 */ 0x00406032 jmp qword [rax*8 + 0x449c70] | 0x00406039 mov bl, byte [r14] | bl = *(r14); 0x0040603c mov eax, ebx | eax = ebx; 0x0040603e cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406043 je 0x406078 | 0x00406045 mov eax, ebx | eax = ebx; 0x00406047 cmp bl, 0xff | | if (bl != 0xff) { 0x0040604a jne 0x406078 | goto label_19; | } 0x0040604c mov edi, 0x44f523 | 0x00406051 mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x00406056 mov esi, 0x24b | esi = 0x24b; 0x0040605b xor eax, eax | eax = 0; 0x0040605d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406062 mov eax, dword [rip + 0x262920] | eax = (anonymous namespace)::testStatus; 0x00406068 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040606b ja 0x406075 | 0x0040606d inc eax | eax++; 0x0040606f mov dword [rip + 0x262913], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406075 mov al, byte [r14] | al = *(r14); | } | label_19: 0x00406078 cmp al, 1 | 0x0040607a mov byte [rsp + 0x2c], bl | *((rsp + 0x2c)) = bl; | if (al == 1) { 0x0040607e jne 0x40608b | 0x00406080 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406085 je 0x407861 | goto label_20; | } | } 0x0040608b cmp byte [rsp + 0x15], 0 | 0x00406090 setne r12b | r12b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x00406094 xor eax, eax | eax = 0; | do { | label_0: 0x00406096 mov dword [rsp + 0x28], eax | *((rsp + 0x28)) = eax; 0x0040609a mov bpl, byte [r14] | bpl = *(r14); 0x0040609d test r12b, r12b | | if (r12b != 0) { 0x004060a0 je 0x4060d1 | 0x004060a2 cmp bpl, 0xff | | if (bpl != 0xff) { 0x004060a6 jne 0x4060d1 | goto label_21; | } 0x004060a8 mov edi, 0x44f523 | 0x004060ad mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x004060b2 mov esi, 0x24d | esi = 0x24d; 0x004060b7 xor eax, eax | eax = 0; 0x004060b9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004060be mov eax, dword [rip + 0x2628c4] | eax = (anonymous namespace)::testStatus; 0x004060c4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004060c7 ja 0x4060d1 | goto label_21; | } 0x004060c9 inc eax | eax++; 0x004060cb mov dword [rip + 0x2628b7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_21: 0x004060d1 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x004060d6 je 0x406496 | 0x004060dc xor ebx, ebx | ebx = 0; 0x004060de cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) == 0) { 0x004060e3 jne 0x4064a4 | 0x004060e9 jmp 0x4064d1 | goto label_22; | label_18: 0x004060ee xor ebx, ebx | ebx = 0; 0x004060f0 mov edi, 0x44f523 | 0x004060f5 mov edx, 0x44d5bf | edx = "\"Unknown State\" && 0"; 0x004060fa mov esi, 0x2ea | esi = 0x2ea; 0x004060ff xor eax, eax | eax = 0; 0x00406101 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406106 mov eax, dword [rip + 0x26287c] | eax = (anonymous namespace)::testStatus; 0x0040610c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040610f ja 0x407850 | goto label_23; | } 0x00406115 inc eax | eax++; 0x00406117 mov dword [rip + 0x26286b], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x0040611d xor ebx, ebx | ebx = 0; 0x0040611f jmp 0x407850 | goto label_23; 0x00406124 mov bpl, byte [r14] | bpl = *(r14); 0x00406127 mov eax, ebp | eax = ebp; 0x00406129 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040612e je 0x406164 | 0x00406130 mov eax, ebp | eax = ebp; 0x00406132 cmp bpl, 0xff | | if (bpl != 0xff) { 0x00406136 jne 0x406164 | goto label_24; | } 0x00406138 mov edi, 0x44f523 | 0x0040613d mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x00406142 mov esi, 0x265 | esi = 0x265; 0x00406147 xor eax, eax | eax = 0; 0x00406149 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040614e mov eax, dword [rip + 0x262834] | eax = (anonymous namespace)::testStatus; 0x00406154 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406157 ja 0x406161 | 0x00406159 inc eax | eax++; 0x0040615b mov dword [rip + 0x262827], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406161 mov al, byte [r14] | al = *(r14); | } | label_24: 0x00406164 cmp al, 1 | | if (al == 1) { 0x00406166 jne 0x406173 | 0x00406168 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x0040616d je 0x4078d2 | goto label_25; | } | } 0x00406173 cmp byte [rsp + 0x15], 0 | 0x00406178 setne r13b | r13b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x0040617c xor eax, eax | eax = 0; | label_1: 0x0040617e mov dword [rsp + 0x2c], eax | *((rsp + 0x2c)) = eax; 0x00406182 mov bl, byte [r14] | bl = *(r14); 0x00406185 test r13b, r13b | | if (r13b != 0) { 0x00406188 je 0x4061b8 | 0x0040618a cmp bl, 0xff | | if (bl != 0xff) { 0x0040618d jne 0x4061b8 | goto label_26; | } 0x0040618f mov edi, 0x44f523 | 0x00406194 mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x00406199 mov esi, 0x267 | esi = 0x267; 0x0040619e xor eax, eax | eax = 0; 0x004061a0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004061a5 mov eax, dword [rip + 0x2627dd] | eax = (anonymous namespace)::testStatus; 0x004061ab cmp eax, 0x64 | | if (eax > 0x64) { 0x004061ae ja 0x4061b8 | goto label_26; | } 0x004061b0 inc eax | eax++; 0x004061b2 mov dword [rip + 0x2627d0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_26: 0x004061b8 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004061bd je 0x4065cf | goto label_27; | } 0x004061c3 xor ecx, ecx | ecx = 0; 0x004061c5 jmp 0x40660a | goto label_28; 0x004061ca mov bpl, byte [r14] | bpl = *(r14); 0x004061cd mov eax, ebp | eax = ebp; 0x004061cf cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004061d4 je 0x40620a | 0x004061d6 mov eax, ebp | eax = ebp; 0x004061d8 cmp bpl, 0xff | | if (bpl != 0xff) { 0x004061dc jne 0x40620a | goto label_29; | } 0x004061de mov edi, 0x44f523 | 0x004061e3 mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x004061e8 mov esi, 0x280 | esi = 0x280; 0x004061ed xor eax, eax | eax = 0; 0x004061ef call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004061f4 mov eax, dword [rip + 0x26278e] | eax = (anonymous namespace)::testStatus; 0x004061fa cmp eax, 0x64 | | if (eax <= 0x64) { 0x004061fd ja 0x406207 | 0x004061ff inc eax | eax++; 0x00406201 mov dword [rip + 0x262781], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406207 mov al, byte [r14] | al = *(r14); | } | label_29: 0x0040620a cmp al, 1 | | if (al == 1) { 0x0040620c jne 0x406219 | 0x0040620e cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406213 je 0x407943 | goto label_30; | } | } 0x00406219 cmp byte [rsp + 0x15], 0 | 0x0040621e setne r13b | r13b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x00406222 xor eax, eax | eax = 0; | label_2: 0x00406224 mov dword [rsp + 0x2c], eax | *((rsp + 0x2c)) = eax; 0x00406228 mov bl, byte [r14] | bl = *(r14); 0x0040622b test r13b, r13b | | if (r13b != 0) { 0x0040622e je 0x40625e | 0x00406230 cmp bl, 0xff | | if (bl != 0xff) { 0x00406233 jne 0x40625e | goto label_31; | } 0x00406235 mov edi, 0x44f523 | 0x0040623a mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x0040623f mov esi, 0x282 | esi = 0x282; 0x00406244 xor eax, eax | eax = 0; 0x00406246 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040624b mov eax, dword [rip + 0x262737] | eax = (anonymous namespace)::testStatus; 0x00406251 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406254 ja 0x40625e | goto label_31; | } 0x00406256 inc eax | eax++; 0x00406258 mov dword [rip + 0x26272a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_31: 0x0040625e cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406263 je 0x40672f | goto label_32; | } 0x00406269 xor ecx, ecx | ecx = 0; 0x0040626b jmp 0x40676a | goto label_33; 0x00406270 mov r13b, byte [r14] | r13b = *(r14); 0x00406273 mov eax, r13d | eax = r13d; 0x00406276 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040627b je 0x4062b2 | 0x0040627d mov eax, r13d | eax = r13d; 0x00406280 cmp r13b, 0xff | | if (r13b != 0xff) { 0x00406284 jne 0x4062b2 | goto label_34; | } 0x00406286 mov edi, 0x44f523 | 0x0040628b mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x00406290 mov esi, 0x29b | esi = 0x29b; 0x00406295 xor eax, eax | eax = 0; 0x00406297 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040629c mov eax, dword [rip + 0x2626e6] | eax = (anonymous namespace)::testStatus; 0x004062a2 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004062a5 ja 0x4062af | 0x004062a7 inc eax | eax++; 0x004062a9 mov dword [rip + 0x2626d9], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004062af mov al, byte [r14] | al = *(r14); | } | label_34: 0x004062b2 cmp al, 1 | | if (al == 1) { 0x004062b4 jne 0x4062c1 | 0x004062b6 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004062bb je 0x4079b4 | goto label_35; | } | } 0x004062c1 cmp byte [rsp + 0x15], 0 | 0x004062c6 setne r12b | r12b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x004062ca xor eax, eax | eax = 0; | label_3: 0x004062cc mov dword [rsp + 0x2c], eax | *((rsp + 0x2c)) = eax; 0x004062d0 mov bl, byte [r14] | bl = *(r14); 0x004062d3 test r12b, r12b | | if (r12b != 0) { 0x004062d6 je 0x406306 | 0x004062d8 cmp bl, 0xff | | if (bl != 0xff) { 0x004062db jne 0x406306 | goto label_36; | } 0x004062dd mov edi, 0x44f523 | 0x004062e2 mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x004062e7 mov esi, 0x29d | esi = 0x29d; 0x004062ec xor eax, eax | eax = 0; 0x004062ee call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004062f3 mov eax, dword [rip + 0x26268f] | eax = (anonymous namespace)::testStatus; 0x004062f9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004062fc ja 0x406306 | goto label_36; | } 0x004062fe inc eax | eax++; 0x00406300 mov dword [rip + 0x262682], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_36: 0x00406306 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x0040630b je 0x40688f | goto label_37; | } 0x00406311 xor ecx, ecx | ecx = 0; 0x00406313 jmp 0x4068ca | goto label_38; 0x00406318 mov bl, byte [r14] | bl = *(r14); 0x0040631b mov eax, ebx | eax = ebx; 0x0040631d cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406322 je 0x406357 | 0x00406324 mov eax, ebx | eax = ebx; 0x00406326 cmp bl, 0xff | | if (bl != 0xff) { 0x00406329 jne 0x406357 | goto label_39; | } 0x0040632b mov edi, 0x44f523 | 0x00406330 mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x00406335 mov esi, 0x2b6 | esi = 0x2b6; 0x0040633a xor eax, eax | eax = 0; 0x0040633c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406341 mov eax, dword [rip + 0x262641] | eax = (anonymous namespace)::testStatus; 0x00406347 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040634a ja 0x406354 | 0x0040634c inc eax | eax++; 0x0040634e mov dword [rip + 0x262634], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406354 mov al, byte [r14] | al = *(r14); | } | label_39: 0x00406357 cmp al, 1 | | if (al == 1) { 0x00406359 jne 0x406366 | 0x0040635b cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406360 je 0x407a25 | goto label_40; | } | } 0x00406366 xor ebp, ebp | ebp = 0; | label_4: 0x00406368 mov byte [rsp + 0x2c], bl | *((rsp + 0x2c)) = bl; 0x0040636c cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406371 je 0x4063a1 | 0x00406373 test bpl, bpl | | if (bpl != 0) { 0x00406376 jne 0x4063a1 | goto label_41; | } 0x00406378 mov edi, 0x44f523 | 0x0040637d mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x00406382 mov esi, 0x2b7 | esi = 0x2b7; 0x00406387 xor eax, eax | eax = 0; 0x00406389 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040638e mov eax, dword [rip + 0x2625f4] | eax = (anonymous namespace)::testStatus; 0x00406394 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406397 ja 0x4063a1 | goto label_41; | } 0x00406399 inc eax | eax++; 0x0040639b mov dword [rip + 0x2625e7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_41: 0x004063a1 cmp byte [rsp + 0x15], 0 | 0x004063a6 setne bl | bl = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x004063a9 mov al, byte [r14] | al = *(r14); 0x004063ac mov byte [rsp + 0x28], al | *((rsp + 0x28)) = al; 0x004063b0 cmp al, 0xff | | if (al == 0xff) { 0x004063b2 jne 0x4063e1 | 0x004063b4 test bl, bl | | if (bl == 0) { 0x004063b6 je 0x4063e1 | goto label_42; | } 0x004063b8 mov edi, 0x44f523 | 0x004063bd mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x004063c2 mov esi, 0x2b8 | esi = 0x2b8; 0x004063c7 xor eax, eax | eax = 0; 0x004063c9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004063ce mov eax, dword [rip + 0x2625b4] | eax = (anonymous namespace)::testStatus; 0x004063d4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004063d7 ja 0x4063e1 | goto label_42; | } 0x004063d9 inc eax | eax++; 0x004063db mov dword [rip + 0x2625a7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_42: 0x004063e1 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004063e6 je 0x4069f4 | goto label_43; | } 0x004063ec xor ecx, ecx | ecx = 0; 0x004063ee jmp 0x406a2e | goto label_44; 0x004063f3 cmp byte [rsp + 0x15], 0 | 0x004063f8 setne r12b | r12b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x004063fc mov bpl, byte [r14] | bpl = *(r14); 0x004063ff mov eax, ebp | eax = ebp; 0x00406401 cmp bpl, 0xff | | if (bpl != 0xff) { 0x00406405 je 0x40643a | 0x00406407 mov eax, ebp | eax = ebp; 0x00406409 test r12b, r12b | | if (r12b == 0) { 0x0040640c je 0x40643a | goto label_45; | } 0x0040640e mov edi, 0x44f523 | 0x00406413 mov edx, 0x44d5d4 | edx = "a0 || !enabled"; 0x00406418 mov esi, 0x2d0 | esi = 0x2d0; 0x0040641d xor eax, eax | eax = 0; 0x0040641f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406424 mov eax, dword [rip + 0x26255e] | eax = (anonymous namespace)::testStatus; 0x0040642a cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040642d ja 0x406437 | 0x0040642f inc eax | eax++; 0x00406431 mov dword [rip + 0x262551], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406437 mov al, byte [r14] | al = *(r14); | } | label_45: 0x0040643a cmp al, 1 | | if (al == 1) { 0x0040643c jne 0x406449 | 0x0040643e cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406443 je 0x407b96 | goto label_46; | } | } 0x00406449 xor r15d, r15d | r15d = 0; | label_14: 0x0040644c mov bl, byte [r14] | bl = *(r14); 0x0040644f cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406454 je 0x406484 | 0x00406456 cmp bl, 0xff | | if (bl == 0xff) { 0x00406459 je 0x406484 | goto label_47; | } 0x0040645b mov edi, 0x44f523 | 0x00406460 mov edx, 0x44d5f2 | edx = "a2 || !enabled"; 0x00406465 mov esi, 0x2d2 | esi = 0x2d2; 0x0040646a xor eax, eax | eax = 0; 0x0040646c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406471 mov eax, dword [rip + 0x262511] | eax = (anonymous namespace)::testStatus; 0x00406477 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040647a ja 0x406484 | goto label_47; | } 0x0040647c inc eax | eax++; 0x0040647e mov dword [rip + 0x262504], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_47: 0x00406484 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406489 je 0x40753d | goto label_48; | } 0x0040648f xor ecx, ecx | ecx = 0; 0x00406491 jmp 0x407578 | | } else { 0x00406496 cmp byte [r14], 0 | 0x0040649a sete bl | bl = (*(r14) == 0) ? 1 : 0; 0x0040649d cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) == 0) { 0x004064a2 je 0x4064d1 | goto label_22; | } | } 0x004064a4 test bl, bl | | if (bl == 0) { 0x004064a6 jne 0x4064d1 | 0x004064a8 mov edi, 0x44f523 | 0x004064ad mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x004064b2 mov esi, 0x24e | esi = 0x24e; 0x004064b7 xor eax, eax | eax = 0; 0x004064b9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004064be mov eax, dword [rip + 0x2624c4] | eax = (anonymous namespace)::testStatus; 0x004064c4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004064c7 ja 0x4064d1 | goto label_22; | } 0x004064c9 inc eax | eax++; 0x004064cb mov dword [rip + 0x2624b7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_22: 0x004064d1 mov dword [rsp + 0x34], ebx | *((rsp + 0x34)) = ebx; 0x004064d5 lea rsi, [rsp + 0x20] | 0x004064da lea rdx, [rsp + 0x30] | 0x004064df mov rdi, r14 | 0x004064e2 mov ecx, 0xffffffff | 0x004064e7 call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x20, rsp + 0x30, 0xffffffff); 0x004064ec mov dword [rsp + 0x18], eax | *((rsp + 0x18)) = eax; 0x004064f0 mov bl, byte [r14] | bl = *(r14); 0x004064f3 mov eax, ebx | eax = ebx; 0x004064f5 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004064fa je 0x40652f | 0x004064fc mov eax, ebx | eax = ebx; 0x004064fe cmp bl, 0xff | | if (bl != 0xff) { 0x00406501 jne 0x40652f | goto label_49; | } 0x00406503 mov edi, 0x44f523 | 0x00406508 mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x0040650d mov esi, 0x253 | esi = 0x253; 0x00406512 xor eax, eax | eax = 0; 0x00406514 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406519 mov eax, dword [rip + 0x262469] | eax = (anonymous namespace)::testStatus; 0x0040651f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406522 ja 0x40652c | 0x00406524 inc eax | eax++; 0x00406526 mov dword [rip + 0x26245c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040652c mov al, byte [r14] | al = *(r14); | } | label_49: 0x0040652f cmp al, 1 | 0x00406531 mov byte [rsp + 0x40], bpl | *((rsp + 0x40)) = bpl; 0x00406536 mov byte [rsp + 0x16], bl | *((rsp + 0x16)) = bl; | if (al == 1) { 0x0040653a jne 0x406547 | 0x0040653c cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406541 je 0x407a51 | goto label_50; | } | } 0x00406547 xor ebp, ebp | ebp = 0; 0x00406549 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040654e je 0x40657e | | label_5: 0x00406550 test bpl, bpl | | if (bpl != 0) { 0x00406553 jne 0x40657e | goto label_6; | } 0x00406555 mov edi, 0x44f523 | 0x0040655a mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x0040655f mov esi, 0x254 | esi = 0x254; 0x00406564 xor eax, eax | eax = 0; 0x00406566 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040656b mov eax, dword [rip + 0x262417] | eax = (anonymous namespace)::testStatus; 0x00406571 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406574 ja 0x40657e | goto label_6; | } 0x00406576 inc eax | eax++; 0x00406578 mov dword [rip + 0x26240a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_6: 0x0040657e mov al, byte [r14] | al = *(r14); 0x00406581 mov byte [rsp + 0x3c], al | *((rsp + 0x3c)) = al; 0x00406585 cmp al, 0xff | 0x00406587 setne al | al = (al != 0xff) ? 1 : 0; 0x0040658a mov ecx, r12d | ecx = r12d; 0x0040658d xor cl, 1 | cl ^= 1; 0x00406590 or cl, al | cl |= al; | if (cl == 0) { 0x00406592 jne 0x4065bd | 0x00406594 mov edi, 0x44f523 | 0x00406599 mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x0040659e mov esi, 0x255 | esi = 0x255; 0x004065a3 xor eax, eax | eax = 0; 0x004065a5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004065aa mov eax, dword [rip + 0x2623d8] | eax = (anonymous namespace)::testStatus; 0x004065b0 cmp eax, 0x64 | | if (eax > 0x64) { 0x004065b3 ja 0x4065bd | goto label_51; | } 0x004065b5 inc eax | eax++; 0x004065b7 mov dword [rip + 0x2623cb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_51: 0x004065bd cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x004065c2 je 0x406af2 | 0x004065c8 xor ecx, ecx | ecx = 0; 0x004065ca jmp 0x406b2d | goto label_52; | label_27: 0x004065cf cmp byte [r14], 0 | 0x004065d3 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x004065d6 mov eax, r13d | eax = r13d; 0x004065d9 and al, cl | al &= cl; 0x004065db cmp al, 1 | | if (al == 1) { 0x004065dd jne 0x40660a | 0x004065df mov edi, 0x44f523 | 0x004065e4 mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x004065e9 mov esi, 0x268 | esi = 0x268; 0x004065ee xor eax, eax | eax = 0; 0x004065f0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004065f5 mov eax, dword [rip + 0x26238d] | eax = (anonymous namespace)::testStatus; 0x004065fb mov cl, 1 | cl = 1; 0x004065fd cmp eax, 0x64 | | if (eax > 0x64) { 0x00406600 ja 0x40660a | goto label_28; | } 0x00406602 inc eax | eax++; 0x00406604 mov dword [rip + 0x26237e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x0040660a mov dword [rsp + 0x40], ecx | *((rsp + 0x40)) = ecx; 0x0040660e mov byte [rsp + 0x28], bl | *((rsp + 0x28)) = bl; 0x00406612 mov byte [rsp + 0x18], bpl | *((rsp + 0x18)) = bpl; 0x00406617 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040661e lea rbp, [rsp + 0x20] | rbp = rsp + 0x20; 0x00406623 lea rbx, [rsp + 0x30] | rbx = rsp + 0x30; 0x00406628 lea rcx, [rsp + 0x44] | 0x0040662d lea r8, [rsp + 0x1f] | 0x00406632 mov rdi, r14 | 0x00406635 mov rsi, rbp | 0x00406638 mov rdx, rbx | 0x0040663b mov r9, r8 | 0x0040663e call 0x421570 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbp, rbx, rsp + 0x44, rsp + 0x1f, r8); 0x00406643 mov rdi, r14 | 0x00406646 mov rsi, rbp | 0x00406649 mov rdx, rbx | 0x0040664c mov ecx, 0xffffffff | 0x00406651 call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbp, rbx, 0xffffffff); 0x00406656 mov ebp, eax | 0x00406658 mov bl, byte [r14] | bl = *(r14); 0x0040665b mov eax, ebx | eax = ebx; 0x0040665d cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406662 je 0x406697 | 0x00406664 mov eax, ebx | eax = ebx; 0x00406666 cmp bl, 0xff | | if (bl != 0xff) { 0x00406669 jne 0x406697 | goto label_53; | } 0x0040666b mov edi, 0x44f523 | 0x00406670 mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x00406675 mov esi, 0x26e | esi = 0x26e; 0x0040667a xor eax, eax | eax = 0; 0x0040667c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406681 mov eax, dword [rip + 0x262301] | eax = (anonymous namespace)::testStatus; 0x00406687 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040668a ja 0x406694 | 0x0040668c inc eax | eax++; 0x0040668e mov dword [rip + 0x2622f4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406694 mov al, byte [r14] | al = *(r14); | } | label_53: 0x00406697 cmp al, 1 | | if (al == 1) { 0x00406699 jne 0x4066a6 | 0x0040669b cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004066a0 je 0x407a88 | goto label_54; | } | } 0x004066a6 xor r12d, r12d | r12d = 0; 0x004066a9 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004066ae je 0x4066de | | label_7: 0x004066b0 test r12b, r12b | | if (r12b != 0) { 0x004066b3 jne 0x4066de | goto label_8; | } 0x004066b5 mov edi, 0x44f523 | 0x004066ba mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x004066bf mov esi, 0x26f | esi = 0x26f; 0x004066c4 xor eax, eax | eax = 0; 0x004066c6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004066cb mov eax, dword [rip + 0x2622b7] | eax = (anonymous namespace)::testStatus; 0x004066d1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004066d4 ja 0x4066de | goto label_8; | } 0x004066d6 inc eax | eax++; 0x004066d8 mov dword [rip + 0x2622aa], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_8: 0x004066de mov al, byte [r14] | al = *(r14); 0x004066e1 mov byte [rsp + 0x3c], al | *((rsp + 0x3c)) = al; 0x004066e5 cmp al, 0xff | 0x004066e7 setne al | al = (al != 0xff) ? 1 : 0; 0x004066ea mov ecx, r13d | ecx = r13d; 0x004066ed xor cl, 1 | cl ^= 1; 0x004066f0 or cl, al | cl |= al; | if (cl == 0) { 0x004066f2 jne 0x40671d | 0x004066f4 mov edi, 0x44f523 | 0x004066f9 mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x004066fe mov esi, 0x270 | esi = 0x270; 0x00406703 xor eax, eax | eax = 0; 0x00406705 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040670a mov eax, dword [rip + 0x262278] | eax = (anonymous namespace)::testStatus; 0x00406710 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406713 ja 0x40671d | goto label_55; | } 0x00406715 inc eax | eax++; 0x00406717 mov dword [rip + 0x26226b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_55: 0x0040671d cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x00406722 je 0x406cf5 | 0x00406728 xor ecx, ecx | ecx = 0; 0x0040672a jmp 0x406d30 | goto label_56; | label_32: 0x0040672f cmp byte [r14], 0 | 0x00406733 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406736 mov eax, r13d | eax = r13d; 0x00406739 and al, cl | al &= cl; 0x0040673b cmp al, 1 | | if (al == 1) { 0x0040673d jne 0x40676a | 0x0040673f mov edi, 0x44f523 | 0x00406744 mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x00406749 mov esi, 0x283 | esi = 0x283; 0x0040674e xor eax, eax | eax = 0; 0x00406750 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406755 mov eax, dword [rip + 0x26222d] | eax = (anonymous namespace)::testStatus; 0x0040675b mov cl, 1 | cl = 1; 0x0040675d cmp eax, 0x64 | | if (eax > 0x64) { 0x00406760 ja 0x40676a | goto label_33; | } 0x00406762 inc eax | eax++; 0x00406764 mov dword [rip + 0x26221e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x0040676a mov dword [rsp + 0x40], ecx | *((rsp + 0x40)) = ecx; 0x0040676e mov byte [rsp + 0x28], bl | *((rsp + 0x28)) = bl; 0x00406772 mov byte [rsp + 0x18], bpl | *((rsp + 0x18)) = bpl; 0x00406777 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040677e lea rbx, [rsp + 0x20] | rbx = rsp + 0x20; 0x00406783 lea rbp, [rsp + 0x30] | rbp = rsp + 0x30; 0x00406788 lea rcx, [rsp + 0x44] | 0x0040678d lea r8, [rsp + 0x1f] | 0x00406792 mov rdi, r14 | 0x00406795 mov rsi, rbx | 0x00406798 mov rdx, rbp | 0x0040679b mov r9, r8 | 0x0040679e call 0x421570 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbx, rbp, rsp + 0x44, rsp + 0x1f, r8); 0x004067a3 mov rdi, r14 | 0x004067a6 mov rsi, rbx | 0x004067a9 mov rdx, rbp | 0x004067ac mov ecx, 0xffffffff | 0x004067b1 call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbx, rbp, 0xffffffff); 0x004067b6 mov ebp, eax | 0x004067b8 mov bl, byte [r14] | bl = *(r14); 0x004067bb mov eax, ebx | eax = ebx; 0x004067bd cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004067c2 je 0x4067f7 | 0x004067c4 mov eax, ebx | eax = ebx; 0x004067c6 cmp bl, 0xff | | if (bl != 0xff) { 0x004067c9 jne 0x4067f7 | goto label_57; | } 0x004067cb mov edi, 0x44f523 | 0x004067d0 mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x004067d5 mov esi, 0x289 | esi = 0x289; 0x004067da xor eax, eax | eax = 0; 0x004067dc call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004067e1 mov eax, dword [rip + 0x2621a1] | eax = (anonymous namespace)::testStatus; 0x004067e7 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004067ea ja 0x4067f4 | 0x004067ec inc eax | eax++; 0x004067ee mov dword [rip + 0x262194], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004067f4 mov al, byte [r14] | al = *(r14); | } | label_57: 0x004067f7 cmp al, 1 | | if (al == 1) { 0x004067f9 jne 0x406806 | 0x004067fb cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406800 je 0x407abf | goto label_58; | } | } 0x00406806 xor r12d, r12d | r12d = 0; 0x00406809 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040680e je 0x40683e | | label_9: 0x00406810 test r12b, r12b | | if (r12b != 0) { 0x00406813 jne 0x40683e | goto label_10; | } 0x00406815 mov edi, 0x44f523 | 0x0040681a mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x0040681f mov esi, 0x28a | esi = 0x28a; 0x00406824 xor eax, eax | eax = 0; 0x00406826 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040682b mov eax, dword [rip + 0x262157] | eax = (anonymous namespace)::testStatus; 0x00406831 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406834 ja 0x40683e | goto label_10; | } 0x00406836 inc eax | eax++; 0x00406838 mov dword [rip + 0x26214a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x0040683e mov al, byte [r14] | al = *(r14); 0x00406841 mov byte [rsp + 0x3c], al | *((rsp + 0x3c)) = al; 0x00406845 cmp al, 0xff | 0x00406847 setne al | al = (al != 0xff) ? 1 : 0; 0x0040684a mov ecx, r13d | ecx = r13d; 0x0040684d xor cl, 1 | cl ^= 1; 0x00406850 or cl, al | cl |= al; | if (cl == 0) { 0x00406852 jne 0x40687d | 0x00406854 mov edi, 0x44f523 | 0x00406859 mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x0040685e mov esi, 0x28b | esi = 0x28b; 0x00406863 xor eax, eax | eax = 0; 0x00406865 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040686a mov eax, dword [rip + 0x262118] | eax = (anonymous namespace)::testStatus; 0x00406870 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406873 ja 0x40687d | goto label_59; | } 0x00406875 inc eax | eax++; 0x00406877 mov dword [rip + 0x26210b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_59: 0x0040687d cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406882 je 0x406f06 | goto label_60; | } 0x00406888 xor ecx, ecx | ecx = 0; 0x0040688a jmp 0x406f41 | goto label_61; | label_37: 0x0040688f cmp byte [r14], 0 | 0x00406893 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406896 mov eax, r12d | eax = r12d; 0x00406899 and al, cl | al &= cl; 0x0040689b cmp al, 1 | | if (al == 1) { 0x0040689d jne 0x4068ca | 0x0040689f mov edi, 0x44f523 | 0x004068a4 mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x004068a9 mov esi, 0x29e | esi = 0x29e; 0x004068ae xor eax, eax | eax = 0; 0x004068b0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004068b5 mov eax, dword [rip + 0x2620cd] | eax = (anonymous namespace)::testStatus; 0x004068bb mov cl, 1 | cl = 1; 0x004068bd cmp eax, 0x64 | | if (eax > 0x64) { 0x004068c0 ja 0x4068ca | goto label_38; | } 0x004068c2 inc eax | eax++; 0x004068c4 mov dword [rip + 0x2620be], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_38: 0x004068ca mov dword [rsp + 0x40], ecx | *((rsp + 0x40)) = ecx; 0x004068ce mov byte [rsp + 0x28], bl | *((rsp + 0x28)) = bl; 0x004068d2 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004068d9 lea rbx, [rsp + 0x20] | rbx = rsp + 0x20; 0x004068de lea rbp, [rsp + 0x30] | rbp = rsp + 0x30; 0x004068e3 lea rcx, [rsp + 0x44] | 0x004068e8 lea r8, [rsp + 0x1f] | 0x004068ed mov rdi, r14 | 0x004068f0 mov rsi, rbx | 0x004068f3 mov rdx, rbp | 0x004068f6 mov r9, r8 | 0x004068f9 call 0x421570 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbx, rbp, rsp + 0x44, rsp + 0x1f, r8); 0x004068fe mov rdi, r14 | 0x00406901 mov rsi, rbx | 0x00406904 mov rdx, rbp | 0x00406907 mov ecx, 0xffffffff | 0x0040690c call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbx, rbp, 0xffffffff); 0x00406911 mov dword [rsp + 0x18], eax | *((rsp + 0x18)) = eax; 0x00406915 mov bl, byte [r14] | bl = *(r14); 0x00406918 mov eax, ebx | eax = ebx; 0x0040691a cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040691f je 0x406954 | 0x00406921 mov eax, ebx | eax = ebx; 0x00406923 cmp bl, 0xff | | if (bl != 0xff) { 0x00406926 jne 0x406954 | goto label_62; | } 0x00406928 mov edi, 0x44f523 | 0x0040692d mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x00406932 mov esi, 0x2a4 | esi = 0x2a4; 0x00406937 xor eax, eax | eax = 0; 0x00406939 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040693e mov eax, dword [rip + 0x262044] | eax = (anonymous namespace)::testStatus; 0x00406944 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406947 ja 0x406951 | 0x00406949 inc eax | eax++; 0x0040694b mov dword [rip + 0x262037], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406951 mov al, byte [r14] | al = *(r14); | } | label_62: 0x00406954 mov byte [rsp + 0x3c], bl | *((rsp + 0x3c)) = bl; 0x00406958 cmp al, 1 | 0x0040695a mov byte [rsp + 0x16], r13b | *((rsp + 0x16)) = r13b; | if (al == 1) { 0x0040695f jne 0x40696c | 0x00406961 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406966 je 0x407af6 | goto label_63; | } | } 0x0040696c xor ebp, ebp | ebp = 0; 0x0040696e cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406973 je 0x4069a3 | | label_11: 0x00406975 test bpl, bpl | | if (bpl != 0) { 0x00406978 jne 0x4069a3 | goto label_12; | } 0x0040697a mov edi, 0x44f523 | 0x0040697f mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x00406984 mov esi, 0x2a5 | esi = 0x2a5; 0x00406989 xor eax, eax | eax = 0; 0x0040698b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406990 mov eax, dword [rip + 0x261ff2] | eax = (anonymous namespace)::testStatus; 0x00406996 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406999 ja 0x4069a3 | goto label_12; | } 0x0040699b inc eax | eax++; 0x0040699d mov dword [rip + 0x261fe5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_12: 0x004069a3 mov al, byte [r14] | al = *(r14); 0x004069a6 mov byte [rsp + 0x17], al | *((rsp + 0x17)) = al; 0x004069aa cmp al, 0xff | 0x004069ac setne al | al = (al != 0xff) ? 1 : 0; 0x004069af mov ecx, r12d | ecx = r12d; 0x004069b2 xor cl, 1 | cl ^= 1; 0x004069b5 or cl, al | cl |= al; | if (cl == 0) { 0x004069b7 jne 0x4069e2 | 0x004069b9 mov edi, 0x44f523 | 0x004069be mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x004069c3 mov esi, 0x2a6 | esi = 0x2a6; 0x004069c8 xor eax, eax | eax = 0; 0x004069ca call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004069cf mov eax, dword [rip + 0x261fb3] | eax = (anonymous namespace)::testStatus; 0x004069d5 cmp eax, 0x64 | | if (eax > 0x64) { 0x004069d8 ja 0x4069e2 | goto label_64; | } 0x004069da inc eax | eax++; 0x004069dc mov dword [rip + 0x261fa6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_64: 0x004069e2 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004069e7 je 0x407128 | goto label_65; | } 0x004069ed xor ecx, ecx | ecx = 0; 0x004069ef jmp 0x407163 | goto label_66; | label_43: 0x004069f4 cmp byte [r14], 0 | 0x004069f8 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x004069fb mov eax, ecx | eax = ecx; 0x004069fd and al, bl | al &= bl; 0x004069ff cmp al, 1 | | if (al == 1) { 0x00406a01 jne 0x406a2e | 0x00406a03 mov edi, 0x44f523 | 0x00406a08 mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x00406a0d mov esi, 0x2b9 | esi = 0x2b9; 0x00406a12 xor eax, eax | eax = 0; 0x00406a14 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406a19 mov eax, dword [rip + 0x261f69] | eax = (anonymous namespace)::testStatus; 0x00406a1f mov cl, 1 | cl = 1; 0x00406a21 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406a24 ja 0x406a2e | goto label_44; | } 0x00406a26 inc eax | eax++; 0x00406a28 mov dword [rip + 0x261f5a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_44: 0x00406a2e mov dword [rsp + 0x40], ecx | *((rsp + 0x40)) = ecx; 0x00406a32 lea rsi, [rsp + 0x20] | 0x00406a37 lea rdx, [rsp + 0x30] | 0x00406a3c mov rdi, r14 | 0x00406a3f mov ecx, 0xffffffff | 0x00406a44 call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x20, rsp + 0x30, 0xffffffff); 0x00406a49 mov r12d, eax | r12d = eax; 0x00406a4c mov dl, byte [r14] | dl = *(r14); 0x00406a4f cmp dl, 0xff | 0x00406a52 sete al | al = (dl == 0xff) ? 1 : 0; 0x00406a55 mov ecx, ebx | ecx = ebx; 0x00406a57 xor cl, 1 | cl ^= 1; 0x00406a5a or cl, al | cl |= al; 0x00406a5c mov byte [rsp + 0x16], dl | *((rsp + 0x16)) = dl; 0x00406a60 mov eax, edx | eax = edx; | if (cl == 0) { 0x00406a62 jne 0x406a90 | 0x00406a64 mov edi, 0x44f523 | 0x00406a69 mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x00406a6e mov esi, 0x2be | esi = 0x2be; 0x00406a73 xor eax, eax | eax = 0; 0x00406a75 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406a7a mov eax, dword [rip + 0x261f08] | eax = (anonymous namespace)::testStatus; 0x00406a80 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406a83 ja 0x406a8d | 0x00406a85 inc eax | eax++; 0x00406a87 mov dword [rip + 0x261efb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406a8d mov al, byte [r14] | al = *(r14); | } 0x00406a90 cmp al, 1 | | if (al == 1) { 0x00406a92 jne 0x406a9f | 0x00406a94 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406a99 je 0x407b2d | goto label_67; | } | } 0x00406a9f xor r13d, r13d | r13d = 0; | label_13: 0x00406aa2 mov al, byte [r14] | al = *(r14); 0x00406aa5 mov byte [rsp + 0x18], al | *((rsp + 0x18)) = al; 0x00406aa9 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406aae je 0x406ae0 | 0x00406ab0 cmp byte [rsp + 0x18], 0xff | | if (*((rsp + 0x18)) == 0xff) { 0x00406ab5 je 0x406ae0 | goto label_68; | } 0x00406ab7 mov edi, 0x44f523 | 0x00406abc mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x00406ac1 mov esi, 0x2c0 | esi = 0x2c0; 0x00406ac6 xor eax, eax | eax = 0; 0x00406ac8 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406acd mov eax, dword [rip + 0x261eb5] | eax = (anonymous namespace)::testStatus; 0x00406ad3 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406ad6 ja 0x406ae0 | goto label_68; | } 0x00406ad8 inc eax | eax++; 0x00406ada mov dword [rip + 0x261ea8], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_68: 0x00406ae0 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406ae5 je 0x407327 | goto label_69; | } 0x00406aeb xor ecx, ecx | ecx = 0; 0x00406aed jmp 0x407360 | | } else { 0x00406af2 cmp byte [r14], 0 | 0x00406af6 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406af9 and r12b, cl | r12b &= cl; 0x00406afc cmp r12b, 1 | | if (r12b == 1) { 0x00406b00 jne 0x406b2d | 0x00406b02 mov edi, 0x44f523 | 0x00406b07 mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x00406b0c mov esi, 0x256 | esi = 0x256; 0x00406b11 xor eax, eax | eax = 0; 0x00406b13 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b18 mov eax, dword [rip + 0x261e6a] | eax = (anonymous namespace)::testStatus; 0x00406b1e mov cl, 1 | cl = 1; 0x00406b20 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406b23 ja 0x406b2d | goto label_52; | } 0x00406b25 inc eax | eax++; 0x00406b27 mov dword [rip + 0x261e5b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_52: 0x00406b2d mov dword [rsp + 0x38], ecx | *((rsp + 0x38)) = ecx; 0x00406b31 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406b36 je 0x406b68 | 0x00406b38 cmp dword [rsp + 0x18], 0 | | if (*((rsp + 0x18)) == 0) { 0x00406b3d je 0x406b68 | goto label_70; | } 0x00406b3f mov edi, 0x44f523 | 0x00406b44 mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x00406b49 mov esi, 0x258 | esi = 0x258; 0x00406b4e xor eax, eax | eax = 0; 0x00406b50 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b55 mov eax, dword [rip + 0x261e2d] | eax = (anonymous namespace)::testStatus; 0x00406b5b cmp eax, 0x64 | | if (eax > 0x64) { 0x00406b5e ja 0x406b68 | goto label_70; | } 0x00406b60 inc eax | eax++; 0x00406b62 mov dword [rip + 0x261e20], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_70: 0x00406b68 mov r13d, dword [rsp + 0x30] | r13d = *((rsp + 0x30)); 0x00406b6d cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406b72 je 0x406ba2 | 0x00406b74 test r13d, r13d | | if (r13d == 0) { 0x00406b77 je 0x406ba2 | goto label_71; | } 0x00406b79 mov edi, 0x44f523 | 0x00406b7e mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x00406b83 mov esi, 0x259 | esi = 0x259; 0x00406b88 xor eax, eax | eax = 0; 0x00406b8a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b8f mov eax, dword [rip + 0x261df3] | eax = (anonymous namespace)::testStatus; 0x00406b95 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406b98 ja 0x406ba2 | goto label_71; | } 0x00406b9a inc eax | eax++; 0x00406b9c mov dword [rip + 0x261de6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_71: 0x00406ba2 mov bl, byte [rsp + 0x20] | bl = *((rsp + 0x20)); 0x00406ba6 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406bab je 0x406bdb | 0x00406bad cmp bl, 0xff | | if (bl == 0xff) { 0x00406bb0 je 0x406bdb | goto label_72; | } 0x00406bb2 mov edi, 0x44f523 | 0x00406bb7 mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x00406bbc mov esi, 0x25b | esi = 0x25b; 0x00406bc1 xor eax, eax | eax = 0; 0x00406bc3 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406bc8 mov eax, dword [rip + 0x261dba] | eax = (anonymous namespace)::testStatus; 0x00406bce cmp eax, 0x64 | | if (eax > 0x64) { 0x00406bd1 ja 0x406bdb | goto label_72; | } 0x00406bd3 inc eax | eax++; 0x00406bd5 mov dword [rip + 0x261dad], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_72: 0x00406bdb mov r12b, byte [rsp + 0x21] | r12b = *((rsp + 0x21)); 0x00406be0 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406be5 je 0x406c16 | 0x00406be7 cmp r12b, 0xff | | if (r12b == 0xff) { 0x00406beb je 0x406c16 | goto label_73; | } 0x00406bed mov edi, 0x44f523 | 0x00406bf2 mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00406bf7 mov esi, 0x25c | esi = 0x25c; 0x00406bfc xor eax, eax | eax = 0; 0x00406bfe call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c03 mov eax, dword [rip + 0x261d7f] | eax = (anonymous namespace)::testStatus; 0x00406c09 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c0c ja 0x406c16 | goto label_73; | } 0x00406c0e inc eax | eax++; 0x00406c10 mov dword [rip + 0x261d72], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_73: 0x00406c16 mov byte [rsp + 0x17], bl | *((rsp + 0x17)) = bl; 0x00406c1a mov r14b, byte [rsp + 0x22] | r14b = *((rsp + 0x22)); 0x00406c1f cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406c24 je 0x406c55 | 0x00406c26 cmp r14b, 0xff | | if (r14b == 0xff) { 0x00406c2a je 0x406c55 | goto label_74; | } 0x00406c2c mov edi, 0x44f523 | 0x00406c31 mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x00406c36 mov esi, 0x25d | esi = 0x25d; 0x00406c3b xor eax, eax | eax = 0; 0x00406c3d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c42 mov eax, dword [rip + 0x261d40] | eax = (anonymous namespace)::testStatus; 0x00406c48 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c4b ja 0x406c55 | goto label_74; | } 0x00406c4d inc eax | eax++; 0x00406c4f mov dword [rip + 0x261d33], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_74: 0x00406c55 mov bl, byte [rsp + 0x23] | bl = *((rsp + 0x23)); 0x00406c59 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406c5e je 0x406c8e | 0x00406c60 cmp bl, 0xff | | if (bl == 0xff) { 0x00406c63 je 0x406c8e | goto label_75; | } 0x00406c65 mov edi, 0x44f523 | 0x00406c6a mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x00406c6f mov esi, 0x25e | esi = 0x25e; 0x00406c74 xor eax, eax | eax = 0; 0x00406c76 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c7b mov eax, dword [rip + 0x261d07] | eax = (anonymous namespace)::testStatus; 0x00406c81 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c84 ja 0x406c8e | goto label_75; | } 0x00406c86 inc eax | eax++; 0x00406c88 mov dword [rip + 0x261cfa], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_75: 0x00406c8e cmp byte [rsp + 0x3c], 0xff | 0x00406c93 sete sil | sil = (*((rsp + 0x3c)) == 0xff) ? 1 : 0; 0x00406c97 cmp byte [rsp + 0x16], 0xff | 0x00406c9c sete cl | cl = (*((rsp + 0x16)) == 0xff) ? 1 : 0; 0x00406c9f cmp byte [rsp + 0x40], 0xff | 0x00406ca4 sete dl | dl = (*((rsp + 0x40)) == 0xff) ? 1 : 0; 0x00406ca7 cmp byte [rsp + 0x2c], 0xff | 0x00406cac sete al | al = (*((rsp + 0x2c)) == 0xff) ? 1 : 0; 0x00406caf mov edi, dword [rsp + 0x28] | edi = *((rsp + 0x28)); 0x00406cb3 or dil, al | dil |= al; 0x00406cb6 mov eax, dword [rsp + 0x34] | eax = *((rsp + 0x34)); 0x00406cba xor al, 1 | al ^= 1; 0x00406cbc or al, dl | al |= dl; 0x00406cbe or al, dil | al |= dil; 0x00406cc1 xor bpl, 1 | bpl ^= 1; 0x00406cc5 or bpl, cl | bpl |= cl; 0x00406cc8 or bpl, sil | bpl |= sil; 0x00406ccb or bpl, al | bpl |= al; 0x00406cce or bpl, byte [rsp + 0x38] | bpl |= *((rsp + 0x38)); 0x00406cd3 and bl, r14b | bl &= r14b; 0x00406cd6 cmp bl, 0xff | 0x00406cd9 sete al | al = (bl == 0xff) ? 1 : 0; 0x00406cdc not bpl | bpl = ~bpl; 0x00406cdf or r13d, dword [rsp + 0x18] | r13d |= *((rsp + 0x18)); 0x00406ce4 sete cl | cl = (r13d == 0) ? 1 : 0; 0x00406ce7 and r12b, byte [rsp + 0x17] | r12b &= *((rsp + 0x17)); 0x00406cec cmp r12b, 0xff | 0x00406cf0 jmp 0x40752e | goto label_76; | } 0x00406cf5 cmp byte [r14], 0 | 0x00406cf9 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406cfc and r13b, cl | r13b &= cl; 0x00406cff cmp r13b, 1 | | if (r13b == 1) { 0x00406d03 jne 0x406d30 | 0x00406d05 mov edi, 0x44f523 | 0x00406d0a mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x00406d0f mov esi, 0x271 | esi = 0x271; 0x00406d14 xor eax, eax | eax = 0; 0x00406d16 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406d1b mov eax, dword [rip + 0x261c67] | eax = (anonymous namespace)::testStatus; 0x00406d21 mov cl, 1 | cl = 1; 0x00406d23 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406d26 ja 0x406d30 | goto label_56; | } 0x00406d28 inc eax | eax++; 0x00406d2a mov dword [rip + 0x261c58], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_56: 0x00406d30 mov dword [rsp + 0x38], ecx | *((rsp + 0x38)) = ecx; 0x00406d34 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406d39 je 0x406d68 | 0x00406d3b test ebp, ebp | | if (ebp == 0) { 0x00406d3d je 0x406d68 | goto label_77; | } 0x00406d3f mov edi, 0x44f523 | 0x00406d44 mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x00406d49 mov esi, 0x273 | esi = 0x273; 0x00406d4e xor eax, eax | eax = 0; 0x00406d50 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406d55 mov eax, dword [rip + 0x261c2d] | eax = (anonymous namespace)::testStatus; 0x00406d5b cmp eax, 0x64 | | if (eax > 0x64) { 0x00406d5e ja 0x406d68 | goto label_77; | } 0x00406d60 inc eax | eax++; 0x00406d62 mov dword [rip + 0x261c20], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_77: 0x00406d68 mov byte [rsp + 0x16], bl | *((rsp + 0x16)) = bl; 0x00406d6c mov ebx, dword [rsp + 0x30] | ebx = *((rsp + 0x30)); 0x00406d70 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406d75 je 0x406da5 | 0x00406d77 cmp ebx, 3 | | if (ebx == 3) { 0x00406d7a je 0x406da5 | goto label_78; | } 0x00406d7c mov edi, 0x44f523 | 0x00406d81 mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x00406d86 mov esi, 0x274 | esi = 0x274; 0x00406d8b xor eax, eax | eax = 0; 0x00406d8d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406d92 mov eax, dword [rip + 0x261bf0] | eax = (anonymous namespace)::testStatus; 0x00406d98 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406d9b ja 0x406da5 | goto label_78; | } 0x00406d9d inc eax | eax++; 0x00406d9f mov dword [rip + 0x261be3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_78: 0x00406da5 mov r15b, byte [rsp + 0x20] | r15b = *((rsp + 0x20)); 0x00406daa cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406daf je 0x406de0 | 0x00406db1 cmp r15b, 0x3d | | if (r15b != 0x3d) { 0x00406db5 jne 0x406de0 | goto label_79; | } 0x00406db7 mov edi, 0x44f523 | 0x00406dbc mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x00406dc1 mov esi, 0x276 | esi = 0x276; 0x00406dc6 xor eax, eax | eax = 0; 0x00406dc8 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406dcd mov eax, dword [rip + 0x261bb5] | eax = (anonymous namespace)::testStatus; 0x00406dd3 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406dd6 ja 0x406de0 | goto label_79; | } 0x00406dd8 inc eax | eax++; 0x00406dda mov dword [rip + 0x261ba8], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_79: 0x00406de0 mov dword [rsp + 0x34], ebx | *((rsp + 0x34)) = ebx; 0x00406de4 mov r14b, byte [rsp + 0x21] | r14b = *((rsp + 0x21)); 0x00406de9 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406dee je 0x406e1f | 0x00406df0 cmp r14b, 0x3d | | if (r14b == 0x3d) { 0x00406df4 je 0x406e1f | goto label_80; | } 0x00406df6 mov edi, 0x44f523 | 0x00406dfb mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00406e00 mov esi, 0x277 | esi = 0x277; 0x00406e05 xor eax, eax | eax = 0; 0x00406e07 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e0c mov eax, dword [rip + 0x261b76] | eax = (anonymous namespace)::testStatus; 0x00406e12 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e15 ja 0x406e1f | goto label_80; | } 0x00406e17 inc eax | eax++; 0x00406e19 mov dword [rip + 0x261b69], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_80: 0x00406e1f mov ebx, ebp | ebx = ebp; 0x00406e21 mov r13b, byte [rsp + 0x22] | r13b = *((rsp + 0x22)); 0x00406e26 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406e2b je 0x406e5c | 0x00406e2d cmp r13b, 0x3d | | if (r13b == 0x3d) { 0x00406e31 je 0x406e5c | goto label_81; | } 0x00406e33 mov edi, 0x44f523 | 0x00406e38 mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x00406e3d mov esi, 0x278 | esi = 0x278; 0x00406e42 xor eax, eax | eax = 0; 0x00406e44 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e49 mov eax, dword [rip + 0x261b39] | eax = (anonymous namespace)::testStatus; 0x00406e4f cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e52 ja 0x406e5c | goto label_81; | } 0x00406e54 inc eax | eax++; 0x00406e56 mov dword [rip + 0x261b2c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_81: 0x00406e5c mov bpl, byte [rsp + 0x23] | bpl = *((rsp + 0x23)); 0x00406e61 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406e66 je 0x406e97 | 0x00406e68 cmp bpl, 0xff | | if (bpl == 0xff) { 0x00406e6c je 0x406e97 | goto label_82; | } 0x00406e6e mov edi, 0x44f523 | 0x00406e73 mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x00406e78 mov esi, 0x279 | esi = 0x279; 0x00406e7d xor eax, eax | eax = 0; 0x00406e7f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e84 mov eax, dword [rip + 0x261afe] | eax = (anonymous namespace)::testStatus; 0x00406e8a cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e8d ja 0x406e97 | goto label_82; | } 0x00406e8f inc eax | eax++; 0x00406e91 mov dword [rip + 0x261af1], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_82: 0x00406e97 not bpl | bpl = ~bpl; 0x00406e9a xor r13b, 0x3d | r13b ^= 0x3d; 0x00406e9e cmp r14b, 0x3d | 0x00406ea2 sete r10b | r10b = (r14b == 0x3d) ? 1 : 0; 0x00406ea6 cmp r15b, 0x3d | 0x00406eaa setne dil | dil = (r15b != 0x3d) ? 1 : 0; 0x00406eae cmp dword [rsp + 0x34], 3 | 0x00406eb3 sete r8b | r8b = (*((rsp + 0x34)) == 3) ? 1 : 0; 0x00406eb7 test ebx, ebx | 0x00406eb9 sete bl | bl = (ebx == 0) ? 1 : 0; 0x00406ebc cmp byte [rsp + 0x3c], 0xff | 0x00406ec1 sete r9b | r9b = (*((rsp + 0x3c)) == 0xff) ? 1 : 0; 0x00406ec5 cmp byte [rsp + 0x16], 0xff | 0x00406eca sete cl | cl = (*((rsp + 0x16)) == 0xff) ? 1 : 0; 0x00406ecd cmp byte [rsp + 0x28], 0xff | 0x00406ed2 sete dl | dl = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x00406ed5 cmp byte [rsp + 0x18], 0xff | 0x00406eda sete al | al = (*((rsp + 0x18)) == 0xff) ? 1 : 0; 0x00406edd mov esi, dword [rsp + 0x2c] | esi = *((rsp + 0x2c)); 0x00406ee1 or sil, al | sil |= al; 0x00406ee4 or sil, dl | sil |= dl; 0x00406ee7 or sil, byte [rsp + 0x40] | sil |= *((rsp + 0x40)); 0x00406eec xor r12b, 1 | r12b ^= 1; 0x00406ef0 or r12b, cl | r12b |= cl; 0x00406ef3 or r12b, r9b | r12b |= r9b; 0x00406ef6 or r12b, sil | r12b |= sil; 0x00406ef9 or r12b, byte [rsp + 0x38] | r12b |= *((rsp + 0x38)); 0x00406efe or r13b, bpl | r13b |= bpl; 0x00406f01 jmp 0x40710f | goto label_83; | label_60: 0x00406f06 cmp byte [r14], 0 | 0x00406f0a sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406f0d and r13b, cl | r13b &= cl; 0x00406f10 cmp r13b, 1 | | if (r13b == 1) { 0x00406f14 jne 0x406f41 | 0x00406f16 mov edi, 0x44f523 | 0x00406f1b mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x00406f20 mov esi, 0x28c | esi = 0x28c; 0x00406f25 xor eax, eax | eax = 0; 0x00406f27 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406f2c mov eax, dword [rip + 0x261a56] | eax = (anonymous namespace)::testStatus; 0x00406f32 mov cl, 1 | cl = 1; 0x00406f34 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406f37 ja 0x406f41 | goto label_61; | } 0x00406f39 inc eax | eax++; 0x00406f3b mov dword [rip + 0x261a47], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_61: 0x00406f41 mov dword [rsp + 0x38], ecx | *((rsp + 0x38)) = ecx; 0x00406f45 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406f4a je 0x406f79 | 0x00406f4c test ebp, ebp | | if (ebp == 0) { 0x00406f4e je 0x406f79 | goto label_84; | } 0x00406f50 mov edi, 0x44f523 | 0x00406f55 mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x00406f5a mov esi, 0x28e | esi = 0x28e; 0x00406f5f xor eax, eax | eax = 0; 0x00406f61 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406f66 mov eax, dword [rip + 0x261a1c] | eax = (anonymous namespace)::testStatus; 0x00406f6c cmp eax, 0x64 | | if (eax > 0x64) { 0x00406f6f ja 0x406f79 | goto label_84; | } 0x00406f71 inc eax | eax++; 0x00406f73 mov dword [rip + 0x261a0f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_84: 0x00406f79 mov byte [rsp + 0x16], bl | *((rsp + 0x16)) = bl; 0x00406f7d mov ebx, dword [rsp + 0x30] | ebx = *((rsp + 0x30)); 0x00406f81 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406f86 je 0x406fb6 | 0x00406f88 cmp ebx, 2 | | if (ebx == 2) { 0x00406f8b je 0x406fb6 | goto label_85; | } 0x00406f8d mov edi, 0x44f523 | 0x00406f92 mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x00406f97 mov esi, 0x28f | esi = 0x28f; 0x00406f9c xor eax, eax | eax = 0; 0x00406f9e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406fa3 mov eax, dword [rip + 0x2619df] | eax = (anonymous namespace)::testStatus; 0x00406fa9 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406fac ja 0x406fb6 | goto label_85; | } 0x00406fae inc eax | eax++; 0x00406fb0 mov dword [rip + 0x2619d2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_85: 0x00406fb6 mov r15b, byte [rsp + 0x20] | r15b = *((rsp + 0x20)); 0x00406fbb cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406fc0 je 0x406ff1 | 0x00406fc2 cmp r15b, 0x3d | | if (r15b != 0x3d) { 0x00406fc6 jne 0x406ff1 | goto label_86; | } 0x00406fc8 mov edi, 0x44f523 | 0x00406fcd mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x00406fd2 mov esi, 0x291 | esi = 0x291; 0x00406fd7 xor eax, eax | eax = 0; 0x00406fd9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406fde mov eax, dword [rip + 0x2619a4] | eax = (anonymous namespace)::testStatus; 0x00406fe4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406fe7 ja 0x406ff1 | goto label_86; | } 0x00406fe9 inc eax | eax++; 0x00406feb mov dword [rip + 0x261997], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_86: 0x00406ff1 mov dword [rsp + 0x34], ebx | *((rsp + 0x34)) = ebx; 0x00406ff5 mov r14b, byte [rsp + 0x21] | r14b = *((rsp + 0x21)); 0x00406ffa cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00406fff je 0x407030 | 0x00407001 cmp r14b, 0x3d | | if (r14b == 0x3d) { 0x00407005 je 0x407030 | goto label_87; | } 0x00407007 mov edi, 0x44f523 | 0x0040700c mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00407011 mov esi, 0x292 | esi = 0x292; 0x00407016 xor eax, eax | eax = 0; 0x00407018 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040701d mov eax, dword [rip + 0x261965] | eax = (anonymous namespace)::testStatus; 0x00407023 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407026 ja 0x407030 | goto label_87; | } 0x00407028 inc eax | eax++; 0x0040702a mov dword [rip + 0x261958], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_87: 0x00407030 mov ebx, ebp | ebx = ebp; 0x00407032 mov r13b, byte [rsp + 0x22] | r13b = *((rsp + 0x22)); 0x00407037 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040703c je 0x40706d | 0x0040703e cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407042 je 0x40706d | goto label_88; | } 0x00407044 mov edi, 0x44f523 | 0x00407049 mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x0040704e mov esi, 0x293 | esi = 0x293; 0x00407053 xor eax, eax | eax = 0; 0x00407055 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040705a mov eax, dword [rip + 0x261928] | eax = (anonymous namespace)::testStatus; 0x00407060 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407063 ja 0x40706d | goto label_88; | } 0x00407065 inc eax | eax++; 0x00407067 mov dword [rip + 0x26191b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_88: 0x0040706d mov bpl, byte [rsp + 0x23] | bpl = *((rsp + 0x23)); 0x00407072 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407077 je 0x4070a8 | 0x00407079 cmp bpl, 0xff | | if (bpl == 0xff) { 0x0040707d je 0x4070a8 | goto label_89; | } 0x0040707f mov edi, 0x44f523 | 0x00407084 mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x00407089 mov esi, 0x294 | esi = 0x294; 0x0040708e xor eax, eax | eax = 0; 0x00407090 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407095 mov eax, dword [rip + 0x2618ed] | eax = (anonymous namespace)::testStatus; 0x0040709b cmp eax, 0x64 | | if (eax > 0x64) { 0x0040709e ja 0x4070a8 | goto label_89; | } 0x004070a0 inc eax | eax++; 0x004070a2 mov dword [rip + 0x2618e0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_89: 0x004070a8 cmp r14b, 0x3d | 0x004070ac sete r10b | r10b = (r14b == 0x3d) ? 1 : 0; 0x004070b0 cmp r15b, 0x3d | 0x004070b4 setne dil | dil = (r15b != 0x3d) ? 1 : 0; 0x004070b8 cmp dword [rsp + 0x34], 2 | 0x004070bd sete r8b | r8b = (*((rsp + 0x34)) == 2) ? 1 : 0; 0x004070c1 test ebx, ebx | 0x004070c3 sete bl | bl = (ebx == 0) ? 1 : 0; 0x004070c6 cmp byte [rsp + 0x3c], 0xff | 0x004070cb sete r9b | r9b = (*((rsp + 0x3c)) == 0xff) ? 1 : 0; 0x004070cf cmp byte [rsp + 0x16], 0xff | 0x004070d4 sete cl | cl = (*((rsp + 0x16)) == 0xff) ? 1 : 0; 0x004070d7 cmp byte [rsp + 0x28], 0xff | 0x004070dc sete dl | dl = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x004070df cmp byte [rsp + 0x18], 0xff | 0x004070e4 sete al | al = (*((rsp + 0x18)) == 0xff) ? 1 : 0; 0x004070e7 mov esi, dword [rsp + 0x2c] | esi = *((rsp + 0x2c)); 0x004070eb or sil, al | sil |= al; 0x004070ee or sil, dl | sil |= dl; 0x004070f1 or sil, byte [rsp + 0x40] | sil |= *((rsp + 0x40)); 0x004070f6 xor r12b, 1 | r12b ^= 1; 0x004070fa or r12b, cl | r12b |= cl; 0x004070fd or r12b, r9b | r12b |= r9b; 0x00407100 or r12b, sil | r12b |= sil; 0x00407103 or r12b, byte [rsp + 0x38] | r12b |= *((rsp + 0x38)); 0x00407108 and bpl, r13b | bpl &= r13b; 0x0040710b cmp bpl, 0xff | | label_83: 0x0040710f sete al | al = (bpl == 0xff) ? 1 : 0; 0x00407112 not r12b | r12b = ~r12b; 0x00407115 and bl, r8b | bl &= r8b; 0x00407118 and bl, dil | bl &= dil; 0x0040711b and bl, r10b | bl &= r10b; 0x0040711e and bl, al | bl &= al; 0x00407120 and bl, r12b | bl &= r12b; 0x00407123 jmp 0x407850 | goto label_23; | label_65: 0x00407128 cmp byte [r14], 0 | 0x0040712c sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x0040712f and r12b, cl | r12b &= cl; 0x00407132 cmp r12b, 1 | | if (r12b == 1) { 0x00407136 jne 0x407163 | 0x00407138 mov edi, 0x44f523 | 0x0040713d mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x00407142 mov esi, 0x2a7 | esi = 0x2a7; 0x00407147 xor eax, eax | eax = 0; 0x00407149 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040714e mov eax, dword [rip + 0x261834] | eax = (anonymous namespace)::testStatus; 0x00407154 mov cl, 1 | cl = 1; 0x00407156 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407159 ja 0x407163 | goto label_66; | } 0x0040715b inc eax | eax++; 0x0040715d mov dword [rip + 0x261825], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_66: 0x00407163 mov dword [rsp + 0x38], ecx | *((rsp + 0x38)) = ecx; 0x00407167 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040716c je 0x40719e | 0x0040716e cmp dword [rsp + 0x18], 0 | | if (*((rsp + 0x18)) == 0) { 0x00407173 je 0x40719e | goto label_90; | } 0x00407175 mov edi, 0x44f523 | 0x0040717a mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x0040717f mov esi, 0x2a9 | esi = 0x2a9; 0x00407184 xor eax, eax | eax = 0; 0x00407186 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040718b mov eax, dword [rip + 0x2617f7] | eax = (anonymous namespace)::testStatus; 0x00407191 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407194 ja 0x40719e | goto label_90; | } 0x00407196 inc eax | eax++; 0x00407198 mov dword [rip + 0x2617ea], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_90: 0x0040719e mov ebx, dword [rsp + 0x30] | ebx = *((rsp + 0x30)); 0x004071a2 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004071a7 je 0x4071d6 | 0x004071a9 test ebx, ebx | | if (ebx == 0) { 0x004071ab je 0x4071d6 | goto label_91; | } 0x004071ad mov edi, 0x44f523 | 0x004071b2 mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x004071b7 mov esi, 0x2aa | esi = 0x2aa; 0x004071bc xor eax, eax | eax = 0; 0x004071be call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004071c3 mov eax, dword [rip + 0x2617bf] | eax = (anonymous namespace)::testStatus; 0x004071c9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004071cc ja 0x4071d6 | goto label_91; | } 0x004071ce inc eax | eax++; 0x004071d0 mov dword [rip + 0x2617b2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_91: 0x004071d6 mov dword [rsp + 0x34], ebx | *((rsp + 0x34)) = ebx; 0x004071da mov r15b, byte [rsp + 0x20] | r15b = *((rsp + 0x20)); 0x004071df cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004071e4 je 0x407215 | 0x004071e6 cmp r15b, 0xff | | if (r15b == 0xff) { 0x004071ea je 0x407215 | goto label_92; | } 0x004071ec mov edi, 0x44f523 | 0x004071f1 mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x004071f6 mov esi, 0x2ac | esi = 0x2ac; 0x004071fb xor eax, eax | eax = 0; 0x004071fd call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407202 mov eax, dword [rip + 0x261780] | eax = (anonymous namespace)::testStatus; 0x00407208 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040720b ja 0x407215 | goto label_92; | } 0x0040720d inc eax | eax++; 0x0040720f mov dword [rip + 0x261773], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_92: 0x00407215 mov r14b, byte [rsp + 0x21] | r14b = *((rsp + 0x21)); 0x0040721a cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040721f je 0x407250 | 0x00407221 cmp r14b, 0xff | | if (r14b == 0xff) { 0x00407225 je 0x407250 | goto label_93; | } 0x00407227 mov edi, 0x44f523 | 0x0040722c mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00407231 mov esi, 0x2ad | esi = 0x2ad; 0x00407236 xor eax, eax | eax = 0; 0x00407238 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040723d mov eax, dword [rip + 0x261745] | eax = (anonymous namespace)::testStatus; 0x00407243 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407246 ja 0x407250 | goto label_93; | } 0x00407248 inc eax | eax++; 0x0040724a mov dword [rip + 0x261738], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_93: 0x00407250 mov r13b, byte [rsp + 0x22] | r13b = *((rsp + 0x22)); 0x00407255 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040725a je 0x40728b | 0x0040725c cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407260 je 0x40728b | goto label_94; | } 0x00407262 mov edi, 0x44f523 | 0x00407267 mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x0040726c mov esi, 0x2ae | esi = 0x2ae; 0x00407271 xor eax, eax | eax = 0; 0x00407273 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407278 mov eax, dword [rip + 0x26170a] | eax = (anonymous namespace)::testStatus; 0x0040727e cmp eax, 0x64 | | if (eax > 0x64) { 0x00407281 ja 0x40728b | goto label_94; | } 0x00407283 inc eax | eax++; 0x00407285 mov dword [rip + 0x2616fd], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_94: 0x0040728b mov r12b, byte [rsp + 0x23] | r12b = *((rsp + 0x23)); 0x00407290 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407295 je 0x4072c6 | 0x00407297 cmp r12b, 0xff | | if (r12b == 0xff) { 0x0040729b je 0x4072c6 | goto label_95; | } 0x0040729d mov edi, 0x44f523 | 0x004072a2 mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x004072a7 mov esi, 0x2af | esi = 0x2af; 0x004072ac xor eax, eax | eax = 0; 0x004072ae call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004072b3 mov eax, dword [rip + 0x2616cf] | eax = (anonymous namespace)::testStatus; 0x004072b9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004072bc ja 0x4072c6 | goto label_95; | } 0x004072be inc eax | eax++; 0x004072c0 mov dword [rip + 0x2616c2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_95: 0x004072c6 cmp byte [rsp + 0x17], 0xff | 0x004072cb sete al | al = (*((rsp + 0x17)) == 0xff) ? 1 : 0; 0x004072ce cmp byte [rsp + 0x3c], 0xff | 0x004072d3 sete cl | cl = (*((rsp + 0x3c)) == 0xff) ? 1 : 0; 0x004072d6 cmp byte [rsp + 0x28], 0xff | 0x004072db sete dl | dl = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x004072de cmp byte [rsp + 0x16], 0xff | 0x004072e3 sete bl | bl = (*((rsp + 0x16)) == 0xff) ? 1 : 0; 0x004072e6 mov esi, dword [rsp + 0x2c] | esi = *((rsp + 0x2c)); 0x004072ea or sil, bl | sil |= bl; 0x004072ed or sil, dl | sil |= dl; 0x004072f0 or sil, byte [rsp + 0x40] | sil |= *((rsp + 0x40)); 0x004072f5 xor bpl, 1 | bpl ^= 1; 0x004072f9 or bpl, cl | bpl |= cl; 0x004072fc or bpl, al | bpl |= al; 0x004072ff or bpl, sil | bpl |= sil; 0x00407302 or bpl, byte [rsp + 0x38] | bpl |= *((rsp + 0x38)); 0x00407307 and r12b, r13b | r12b &= r13b; 0x0040730a cmp r12b, 0xff | 0x0040730e sete al | al = (r12b == 0xff) ? 1 : 0; 0x00407311 not bpl | bpl = ~bpl; 0x00407314 mov ecx, dword [rsp + 0x34] | ecx = *((rsp + 0x34)); 0x00407318 or ecx, dword [rsp + 0x18] | ecx |= *((rsp + 0x18)); 0x0040731c sete cl | cl = (ecx == 0) ? 1 : 0; 0x0040731f and r14b, r15b | r14b &= r15b; 0x00407322 jmp 0x40752a | goto label_96; | label_69: 0x00407327 cmp byte [r14], 0 | 0x0040732b sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x0040732e and bl, cl | bl &= cl; 0x00407330 cmp bl, 1 | | if (bl != 1) { 0x00407333 jne 0x407360 | goto label_97; | } 0x00407335 mov edi, 0x44f523 | 0x0040733a mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x0040733f mov esi, 0x2c1 | esi = 0x2c1; 0x00407344 xor eax, eax | eax = 0; 0x00407346 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040734b mov eax, dword [rip + 0x261637] | eax = (anonymous namespace)::testStatus; 0x00407351 mov cl, 1 | cl = 1; 0x00407353 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407356 ja 0x407360 | goto label_97; | } 0x00407358 inc eax | eax++; 0x0040735a mov dword [rip + 0x261628], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_97: 0x00407360 mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x00407364 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407369 je 0x40739a | 0x0040736b cmp r12d, 0xffffffff | | if (r12d == 0xffffffff) { 0x0040736f je 0x40739a | goto label_98; | } 0x00407371 mov edi, 0x44f523 | 0x00407376 mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x0040737b mov esi, 0x2c3 | esi = 0x2c3; 0x00407380 xor eax, eax | eax = 0; 0x00407382 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407387 mov eax, dword [rip + 0x2615fb] | eax = (anonymous namespace)::testStatus; 0x0040738d cmp eax, 0x64 | | if (eax > 0x64) { 0x00407390 ja 0x40739a | goto label_98; | } 0x00407392 inc eax | eax++; 0x00407394 mov dword [rip + 0x2615ee], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_98: 0x0040739a mov dword [rsp + 0x3c], r12d | *((rsp + 0x3c)) = r12d; 0x0040739f mov r15d, dword [rsp + 0x30] | r15d = *((rsp + 0x30)); 0x004073a4 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004073a9 je 0x4073d9 | 0x004073ab test r15d, r15d | | if (r15d == 0) { 0x004073ae je 0x4073d9 | goto label_99; | } 0x004073b0 mov edi, 0x44f523 | 0x004073b5 mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x004073ba mov esi, 0x2c4 | esi = 0x2c4; 0x004073bf xor eax, eax | eax = 0; 0x004073c1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004073c6 mov eax, dword [rip + 0x2615bc] | eax = (anonymous namespace)::testStatus; 0x004073cc cmp eax, 0x64 | | if (eax > 0x64) { 0x004073cf ja 0x4073d9 | goto label_99; | } 0x004073d1 inc eax | eax++; 0x004073d3 mov dword [rip + 0x2615af], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_99: 0x004073d9 mov r12b, byte [rsp + 0x20] | r12b = *((rsp + 0x20)); 0x004073de cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004073e3 je 0x407414 | 0x004073e5 cmp r12b, 0xff | | if (r12b == 0xff) { 0x004073e9 je 0x407414 | goto label_100; | } 0x004073eb mov edi, 0x44f523 | 0x004073f0 mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x004073f5 mov esi, 0x2c6 | esi = 0x2c6; 0x004073fa xor eax, eax | eax = 0; 0x004073fc call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407401 mov eax, dword [rip + 0x261581] | eax = (anonymous namespace)::testStatus; 0x00407407 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040740a ja 0x407414 | goto label_100; | } 0x0040740c inc eax | eax++; 0x0040740e mov dword [rip + 0x261574], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_100: 0x00407414 mov dword [rsp + 0x38], r13d | *((rsp + 0x38)) = r13d; 0x00407419 mov r14b, byte [rsp + 0x21] | r14b = *((rsp + 0x21)); 0x0040741e cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407423 je 0x407454 | 0x00407425 cmp r14b, 0xff | | if (r14b == 0xff) { 0x00407429 je 0x407454 | goto label_101; | } 0x0040742b mov edi, 0x44f523 | 0x00407430 mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00407435 mov esi, 0x2c7 | esi = 0x2c7; 0x0040743a xor eax, eax | eax = 0; 0x0040743c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407441 mov eax, dword [rip + 0x261541] | eax = (anonymous namespace)::testStatus; 0x00407447 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040744a ja 0x407454 | goto label_101; | } 0x0040744c inc eax | eax++; 0x0040744e mov dword [rip + 0x261534], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_101: 0x00407454 mov r13b, byte [rsp + 0x22] | r13b = *((rsp + 0x22)); 0x00407459 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x0040745e je 0x40748f | 0x00407460 cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407464 je 0x40748f | goto label_102; | } 0x00407466 mov edi, 0x44f523 | 0x0040746b mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x00407470 mov esi, 0x2c8 | esi = 0x2c8; 0x00407475 xor eax, eax | eax = 0; 0x00407477 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040747c mov eax, dword [rip + 0x261506] | eax = (anonymous namespace)::testStatus; 0x00407482 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407485 ja 0x40748f | goto label_102; | } 0x00407487 inc eax | eax++; 0x00407489 mov dword [rip + 0x2614f9], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_102: 0x0040748f mov bl, byte [rsp + 0x23] | bl = *((rsp + 0x23)); 0x00407493 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407498 je 0x4074c8 | 0x0040749a cmp bl, 0xff | | if (bl == 0xff) { 0x0040749d je 0x4074c8 | goto label_103; | } 0x0040749f mov edi, 0x44f523 | 0x004074a4 mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x004074a9 mov esi, 0x2c9 | esi = 0x2c9; 0x004074ae xor eax, eax | eax = 0; 0x004074b0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004074b5 mov eax, dword [rip + 0x2614cd] | eax = (anonymous namespace)::testStatus; 0x004074bb cmp eax, 0x64 | | if (eax > 0x64) { 0x004074be ja 0x4074c8 | goto label_103; | } 0x004074c0 inc eax | eax++; 0x004074c2 mov dword [rip + 0x2614c0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_103: 0x004074c8 test r15d, r15d | 0x004074cb sete sil | sil = (r15d == 0) ? 1 : 0; 0x004074cf cmp dword [rsp + 0x3c], 0xffffffff | 0x004074d4 sete cl | cl = (*((rsp + 0x3c)) == 0xffffffff) ? 1 : 0; 0x004074d7 cmp byte [rsp + 0x18], 0xff | 0x004074dc setne dil | dil = (*((rsp + 0x18)) != 0xff) ? 1 : 0; 0x004074e0 cmp byte [rsp + 0x16], 0xff | 0x004074e5 setne r8b | r8b = (*((rsp + 0x16)) != 0xff) ? 1 : 0; 0x004074e9 cmp byte [rsp + 0x28], 0xff | 0x004074ee sete dl | dl = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x004074f1 cmp byte [rsp + 0x2c], 0xff | 0x004074f6 sete al | al = (*((rsp + 0x2c)) == 0xff) ? 1 : 0; 0x004074f9 xor bpl, 1 | bpl ^= 1; 0x004074fd or bpl, al | bpl |= al; 0x00407500 or bpl, dl | bpl |= dl; 0x00407503 or bpl, byte [rsp + 0x40] | bpl |= *((rsp + 0x40)); 0x00407508 or bpl, r8b | bpl |= r8b; 0x0040750b or bpl, byte [rsp + 0x38] | bpl |= *((rsp + 0x38)); 0x00407510 or bpl, dil | bpl |= dil; 0x00407513 or bpl, byte [rsp + 0x34] | bpl |= *((rsp + 0x34)); 0x00407518 and bl, r13b | bl &= r13b; 0x0040751b cmp bl, 0xff | 0x0040751e sete al | al = (bl == 0xff) ? 1 : 0; 0x00407521 not bpl | bpl = ~bpl; 0x00407524 and cl, sil | cl &= sil; 0x00407527 and r14b, r12b | r14b &= r12b; | label_96: 0x0040752a cmp r14b, 0xff | | label_76: 0x0040752e sete bl | bl = (r14b == 0xff) ? 1 : 0; 0x00407531 and bl, cl | bl &= cl; 0x00407533 and bl, al | bl &= al; 0x00407535 and bl, bpl | bl &= bpl; 0x00407538 jmp 0x407850 | goto label_23; | label_48: 0x0040753d cmp byte [r14], 0 | 0x00407541 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00407544 mov eax, ecx | eax = ecx; 0x00407546 and al, r12b | al &= r12b; 0x00407549 cmp al, 1 | | if (al != 1) { 0x0040754b jne 0x407578 | goto label_104; | } 0x0040754d mov edi, 0x44f523 | 0x00407552 mov edx, 0x44d601 | edx = "a3 || !enabled"; 0x00407557 mov esi, 0x2d3 | esi = 0x2d3; 0x0040755c xor eax, eax | eax = 0; 0x0040755e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407563 mov eax, dword [rip + 0x26141f] | eax = (anonymous namespace)::testStatus; 0x00407569 mov cl, 1 | cl = 1; 0x0040756b cmp eax, 0x64 | | if (eax > 0x64) { 0x0040756e ja 0x407578 | goto label_104; | } 0x00407570 inc eax | eax++; 0x00407572 mov dword [rip + 0x261410], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_104: 0x00407578 mov dword [rsp + 0x3c], ecx | *((rsp + 0x3c)) = ecx; 0x0040757c lea rsi, [rsp + 0x20] | 0x00407581 lea rdx, [rsp + 0x30] | 0x00407586 mov rdi, r14 | 0x00407589 mov ecx, 0xffffffff | 0x0040758e call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x20, rsp + 0x30, 0xffffffff); 0x00407593 mov dword [rsp + 0x18], eax | *((rsp + 0x18)) = eax; 0x00407597 mov dl, byte [r14] | dl = *(r14); 0x0040759a cmp dl, 0xff | 0x0040759d sete al | al = (dl == 0xff) ? 1 : 0; 0x004075a0 mov ecx, r12d | ecx = r12d; 0x004075a3 xor cl, 1 | cl ^= 1; 0x004075a6 or cl, al | cl |= al; 0x004075a8 mov byte [rsp + 0x38], dl | *((rsp + 0x38)) = dl; 0x004075ac mov eax, edx | eax = edx; | if (cl == 0) { 0x004075ae jne 0x4075dc | 0x004075b0 mov edi, 0x44f523 | 0x004075b5 mov edx, 0x44d610 | edx = "b0 || !enabled"; 0x004075ba mov esi, 0x2d8 | esi = 0x2d8; 0x004075bf xor eax, eax | eax = 0; 0x004075c1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004075c6 mov eax, dword [rip + 0x2613bc] | eax = (anonymous namespace)::testStatus; 0x004075cc cmp eax, 0x64 | | if (eax <= 0x64) { 0x004075cf ja 0x4075d9 | 0x004075d1 inc eax | eax++; 0x004075d3 mov dword [rip + 0x2613af], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004075d9 mov al, byte [r14] | al = *(r14); | } 0x004075dc cmp al, 1 | | if (al == 1) { 0x004075de jne 0x4075eb | 0x004075e0 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004075e5 je 0x407c00 | goto label_105; | } | } 0x004075eb mov dword [rsp + 0x28], 0 | *((rsp + 0x28)) = 0; | label_15: 0x004075f3 mov al, byte [r14] | al = *(r14); 0x004075f6 mov byte [rsp + 0x2c], al | *((rsp + 0x2c)) = al; 0x004075fa cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004075ff je 0x407631 | 0x00407601 cmp byte [rsp + 0x2c], 0xff | | if (*((rsp + 0x2c)) == 0xff) { 0x00407606 je 0x407631 | goto label_106; | } 0x00407608 mov edi, 0x44f523 | 0x0040760d mov edx, 0x44d62e | edx = "b2 || !enabled"; 0x00407612 mov esi, 0x2da | esi = 0x2da; 0x00407617 xor eax, eax | eax = 0; 0x00407619 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040761e mov eax, dword [rip + 0x261364] | eax = (anonymous namespace)::testStatus; 0x00407624 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407627 ja 0x407631 | goto label_106; | } 0x00407629 inc eax | eax++; 0x0040762b mov dword [rip + 0x261357], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_106: 0x00407631 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x00407636 je 0x40763c | 0x00407638 xor ecx, ecx | ecx = 0; 0x0040763a jmp 0x407677 | | } else { 0x0040763c cmp byte [r14], 0 | 0x00407640 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00407643 and r12b, cl | r12b &= cl; 0x00407646 cmp r12b, 1 | | if (r12b != 1) { 0x0040764a jne 0x407677 | goto label_107; | } 0x0040764c mov edi, 0x44f523 | 0x00407651 mov edx, 0x44d63d | edx = "b3 || !enabled"; 0x00407656 mov esi, 0x2db | esi = 0x2db; 0x0040765b xor eax, eax | eax = 0; 0x0040765d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407662 mov eax, dword [rip + 0x261320] | eax = (anonymous namespace)::testStatus; 0x00407668 mov cl, 1 | cl = 1; 0x0040766a cmp eax, 0x64 | | if (eax > 0x64) { 0x0040766d ja 0x407677 | goto label_107; | } 0x0040766f inc eax | eax++; 0x00407671 mov dword [rip + 0x261311], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_107: 0x00407677 mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x0040767b mov dword [rsp + 0x40], r15d | *((rsp + 0x40)) = r15d; 0x00407680 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407685 je 0x4076b7 | 0x00407687 cmp dword [rsp + 0x18], 0xffffffff | | if (*((rsp + 0x18)) == 0xffffffff) { 0x0040768c je 0x4076b7 | goto label_108; | } 0x0040768e mov edi, 0x44f523 | 0x00407693 mov edx, 0x44d64c | edx = "c0 || !enabled"; 0x00407698 mov esi, 0x2dd | esi = 0x2dd; 0x0040769d xor eax, eax | eax = 0; 0x0040769f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004076a4 mov eax, dword [rip + 0x2612de] | eax = (anonymous namespace)::testStatus; 0x004076aa cmp eax, 0x64 | | if (eax > 0x64) { 0x004076ad ja 0x4076b7 | goto label_108; | } 0x004076af inc eax | eax++; 0x004076b1 mov dword [rip + 0x2612d1], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_108: 0x004076b7 mov r13d, dword [rsp + 0x30] | r13d = *((rsp + 0x30)); 0x004076bc cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004076c1 je 0x4076f1 | 0x004076c3 test r13d, r13d | | if (r13d == 0) { 0x004076c6 je 0x4076f1 | goto label_109; | } 0x004076c8 mov edi, 0x44f523 | 0x004076cd mov edx, 0x44d65b | edx = "c1 || !enabled"; 0x004076d2 mov esi, 0x2de | esi = 0x2de; 0x004076d7 xor eax, eax | eax = 0; 0x004076d9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004076de mov eax, dword [rip + 0x2612a4] | eax = (anonymous namespace)::testStatus; 0x004076e4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004076e7 ja 0x4076f1 | goto label_109; | } 0x004076e9 inc eax | eax++; 0x004076eb mov dword [rip + 0x261297], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_109: 0x004076f1 mov r14d, ebx | r14d = ebx; 0x004076f4 mov bl, byte [rsp + 0x20] | bl = *((rsp + 0x20)); 0x004076f8 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x004076fd je 0x40772d | 0x004076ff cmp bl, 0xff | | if (bl == 0xff) { 0x00407702 je 0x40772d | goto label_110; | } 0x00407704 mov edi, 0x44f523 | 0x00407709 mov edx, 0x44d66a | edx = "d0 || !enabled"; 0x0040770e mov esi, 0x2e0 | esi = 0x2e0; 0x00407713 xor eax, eax | eax = 0; 0x00407715 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040771a mov eax, dword [rip + 0x261268] | eax = (anonymous namespace)::testStatus; 0x00407720 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407723 ja 0x40772d | goto label_110; | } 0x00407725 inc eax | eax++; 0x00407727 mov dword [rip + 0x26125b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_110: 0x0040772d mov byte [rsp + 0x17], bl | *((rsp + 0x17)) = bl; 0x00407731 mov r12b, byte [rsp + 0x21] | r12b = *((rsp + 0x21)); 0x00407736 mov al, byte [rsp + 0x15] | al = *((rsp + 0x15)); 0x0040773a mov r15d, eax | r15d = eax; 0x0040773d test al, al | | if (al != 0) { 0x0040773f je 0x407770 | 0x00407741 cmp r12b, 0xff | | if (r12b == 0xff) { 0x00407745 je 0x407770 | goto label_111; | } 0x00407747 mov edi, 0x44f523 | 0x0040774c mov edx, 0x44d679 | edx = "d1 || !enabled"; 0x00407751 mov esi, 0x2e1 | esi = 0x2e1; 0x00407756 xor eax, eax | eax = 0; 0x00407758 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040775d mov eax, dword [rip + 0x261225] | eax = (anonymous namespace)::testStatus; 0x00407763 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407766 ja 0x407770 | goto label_111; | } 0x00407768 inc eax | eax++; 0x0040776a mov dword [rip + 0x261218], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_111: 0x00407770 mov byte [rsp + 0x16], r14b | *((rsp + 0x16)) = r14b; 0x00407775 mov r14b, byte [rsp + 0x22] | r14b = *((rsp + 0x22)); 0x0040777a test r15b, r15b | 0x0040777d mov ebx, r13d | ebx = r13d; | if (r15b != 0) { 0x00407780 je 0x4077b1 | 0x00407782 cmp r14b, 0xff | | if (r14b == 0xff) { 0x00407786 je 0x4077b1 | goto label_112; | } 0x00407788 mov edi, 0x44f523 | 0x0040778d mov edx, 0x44d688 | edx = "d2 || !enabled"; 0x00407792 mov esi, 0x2e2 | esi = 0x2e2; 0x00407797 xor eax, eax | eax = 0; 0x00407799 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040779e mov eax, dword [rip + 0x2611e4] | eax = (anonymous namespace)::testStatus; 0x004077a4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004077a7 ja 0x4077b1 | goto label_112; | } 0x004077a9 inc eax | eax++; 0x004077ab mov dword [rip + 0x2611d7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_112: 0x004077b1 mov r13b, byte [rsp + 0x23] | r13b = *((rsp + 0x23)); 0x004077b6 test r15b, r15b | | if (r15b != 0) { 0x004077b9 je 0x4077ea | 0x004077bb cmp r13b, 0xff | | if (r13b == 0xff) { 0x004077bf je 0x4077ea | goto label_113; | } 0x004077c1 mov edi, 0x44f523 | 0x004077c6 mov edx, 0x44d697 | edx = "d3 || !enabled"; 0x004077cb mov esi, 0x2e3 | esi = 0x2e3; 0x004077d0 xor eax, eax | eax = 0; 0x004077d2 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004077d7 mov eax, dword [rip + 0x2611ab] | eax = (anonymous namespace)::testStatus; 0x004077dd cmp eax, 0x64 | | if (eax > 0x64) { 0x004077e0 ja 0x4077ea | goto label_113; | } 0x004077e2 inc eax | eax++; 0x004077e4 mov dword [rip + 0x26119e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_113: 0x004077ea test ebx, ebx | 0x004077ec sete sil | sil = (ebx == 0) ? 1 : 0; 0x004077f0 cmp dword [rsp + 0x18], 0xffffffff | 0x004077f5 sete cl | cl = (*((rsp + 0x18)) == 0xffffffff) ? 1 : 0; 0x004077f8 cmp byte [rsp + 0x2c], 0xff | 0x004077fd setne dil | dil = (*((rsp + 0x2c)) != 0xff) ? 1 : 0; 0x00407801 cmp byte [rsp + 0x38], 0xff | 0x00407806 setne bl | bl = (*((rsp + 0x38)) != 0xff) ? 1 : 0; 0x00407809 cmp byte [rsp + 0x16], 0xff | 0x0040780e setne al | al = (*((rsp + 0x16)) != 0xff) ? 1 : 0; 0x00407811 cmp bpl, 0xff | 0x00407815 setne dl | dl = (bpl != 0xff) ? 1 : 0; 0x00407818 or dl, byte [rsp + 0x40] | dl |= *((rsp + 0x40)); 0x0040781c or dl, al | dl |= al; 0x0040781e or dl, byte [rsp + 0x3c] | dl |= *((rsp + 0x3c)); 0x00407822 or dl, bl | dl |= bl; 0x00407824 or dl, byte [rsp + 0x28] | dl |= *((rsp + 0x28)); 0x00407828 or dl, dil | dl |= dil; 0x0040782b or dl, byte [rsp + 0x34] | dl |= *((rsp + 0x34)); 0x0040782f and r13b, r14b | r13b &= r14b; 0x00407832 cmp r13b, 0xff | 0x00407836 sete al | al = (r13b == 0xff) ? 1 : 0; 0x00407839 not dl | dl = ~dl; 0x0040783b and cl, sil | cl &= sil; 0x0040783e and r12b, byte [rsp + 0x17] | r12b &= *((rsp + 0x17)); 0x00407843 cmp r12b, 0xff | 0x00407847 sete bl | bl = (r12b == 0xff) ? 1 : 0; 0x0040784a and bl, cl | bl &= cl; 0x0040784c and bl, al | bl &= al; 0x0040784e and bl, dl | bl &= dl; | label_23: 0x00407850 mov eax, ebx | eax = ebx; 0x00407852 add rsp, 0x48 | 0x00407856 pop rbx | 0x00407857 pop r12 | 0x00407859 pop r13 | 0x0040785b pop r14 | 0x0040785d pop r15 | 0x0040785f pop rbp | 0x00407860 ret | return eax; | label_20: 0x00407861 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407865 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407869 test ecx, ecx | | if (ecx != 0) { 0x0040786b je 0x407882 | 0x0040786d lea esi, [rcx + 2] | esi = rcx + 2; 0x00407870 cdq | edx:eax = (int64_t) eax; 0x00407871 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407873 xor esi, esi | esi = 0; 0x00407875 cmp edx, ecx | 0x00407877 setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040787b imul eax, ecx | eax *= ecx; 0x0040787e add eax, edx | eax += edx; 0x00407880 sub eax, esi | eax -= esi; | } 0x00407882 cmp byte [rsp + 0x15], 0 | 0x00407887 setne r12b | r12b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x0040788b test al, 3 | 0x0040788d sete al | al = ((al & 3) == 0) ? 1 : 0; 0x00407890 jne 0x406096 | | } while ((al & 3) != 0); 0x00407896 test r12b, r12b | | if (r12b == 0) { 0x00407899 je 0x406096 | goto label_0; | } 0x0040789f mov edi, 0x44f523 | 0x004078a4 mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x004078a9 mov esi, 0x24c | esi = 0x24c; 0x004078ae xor eax, eax | eax = 0; 0x004078b0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004078b5 mov eax, dword [rip + 0x2610cd] | eax = (anonymous namespace)::testStatus; 0x004078bb mov r12b, 1 | r12b = 1; 0x004078be cmp eax, 0x64 | | if (eax <= 0x64) { 0x004078c1 ja 0x4078cb | 0x004078c3 inc eax | eax++; 0x004078c5 mov dword [rip + 0x2610bd], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004078cb mov al, 1 | al = 1; 0x004078cd jmp 0x406096 | goto label_0; | label_25: 0x004078d2 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x004078d6 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x004078da test ecx, ecx | | if (ecx != 0) { 0x004078dc je 0x4078f3 | 0x004078de lea esi, [rcx + 2] | esi = rcx + 2; 0x004078e1 cdq | edx:eax = (int64_t) eax; 0x004078e2 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x004078e4 xor esi, esi | esi = 0; 0x004078e6 cmp edx, ecx | 0x004078e8 setg sil | sil = (edx > ecx) ? 1 : 0; 0x004078ec imul eax, ecx | eax *= ecx; 0x004078ef add eax, edx | eax += edx; 0x004078f1 sub eax, esi | eax -= esi; | } 0x004078f3 cmp byte [rsp + 0x15], 0 | 0x004078f8 setne r13b | r13b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x004078fc test al, 3 | 0x004078fe sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x00407901 jne 0x40617e | goto label_1; | } 0x00407907 test r13b, r13b | | if (r13b == 0) { 0x0040790a je 0x40617e | goto label_1; | } 0x00407910 mov edi, 0x44f523 | 0x00407915 mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x0040791a mov esi, 0x266 | esi = 0x266; 0x0040791f xor eax, eax | eax = 0; 0x00407921 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407926 mov eax, dword [rip + 0x26105c] | eax = (anonymous namespace)::testStatus; 0x0040792c mov r13b, 1 | r13b = 1; 0x0040792f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00407932 ja 0x40793c | 0x00407934 inc eax | eax++; 0x00407936 mov dword [rip + 0x26104c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040793c mov al, 1 | al = 1; 0x0040793e jmp 0x40617e | goto label_1; | label_30: 0x00407943 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407947 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x0040794b test ecx, ecx | | if (ecx != 0) { 0x0040794d je 0x407964 | 0x0040794f lea esi, [rcx + 2] | esi = rcx + 2; 0x00407952 cdq | edx:eax = (int64_t) eax; 0x00407953 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407955 xor esi, esi | esi = 0; 0x00407957 cmp edx, ecx | 0x00407959 setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040795d imul eax, ecx | eax *= ecx; 0x00407960 add eax, edx | eax += edx; 0x00407962 sub eax, esi | eax -= esi; | } 0x00407964 cmp byte [rsp + 0x15], 0 | 0x00407969 setne r13b | r13b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x0040796d test al, 3 | 0x0040796f sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x00407972 jne 0x406224 | goto label_2; | } 0x00407978 test r13b, r13b | | if (r13b == 0) { 0x0040797b je 0x406224 | goto label_2; | } 0x00407981 mov edi, 0x44f523 | 0x00407986 mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x0040798b mov esi, 0x281 | esi = 0x281; 0x00407990 xor eax, eax | eax = 0; 0x00407992 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407997 mov eax, dword [rip + 0x260feb] | eax = (anonymous namespace)::testStatus; 0x0040799d mov r13b, 1 | r13b = 1; 0x004079a0 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004079a3 ja 0x4079ad | 0x004079a5 inc eax | eax++; 0x004079a7 mov dword [rip + 0x260fdb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004079ad mov al, 1 | al = 1; 0x004079af jmp 0x406224 | goto label_2; | label_35: 0x004079b4 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x004079b8 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x004079bc test ecx, ecx | | if (ecx != 0) { 0x004079be je 0x4079d5 | 0x004079c0 lea esi, [rcx + 2] | esi = rcx + 2; 0x004079c3 cdq | edx:eax = (int64_t) eax; 0x004079c4 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x004079c6 xor esi, esi | esi = 0; 0x004079c8 cmp edx, ecx | 0x004079ca setg sil | sil = (edx > ecx) ? 1 : 0; 0x004079ce imul eax, ecx | eax *= ecx; 0x004079d1 add eax, edx | eax += edx; 0x004079d3 sub eax, esi | eax -= esi; | } 0x004079d5 cmp byte [rsp + 0x15], 0 | 0x004079da setne r12b | r12b = (*((rsp + 0x15)) != 0) ? 1 : 0; 0x004079de test al, 3 | 0x004079e0 sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x004079e3 jne 0x4062cc | goto label_3; | } 0x004079e9 test r12b, r12b | | if (r12b == 0) { 0x004079ec je 0x4062cc | goto label_3; | } 0x004079f2 mov edi, 0x44f523 | 0x004079f7 mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x004079fc mov esi, 0x29c | esi = 0x29c; 0x00407a01 xor eax, eax | eax = 0; 0x00407a03 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407a08 mov eax, dword [rip + 0x260f7a] | eax = (anonymous namespace)::testStatus; 0x00407a0e mov r12b, 1 | r12b = 1; 0x00407a11 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00407a14 ja 0x407a1e | 0x00407a16 inc eax | eax++; 0x00407a18 mov dword [rip + 0x260f6a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00407a1e mov al, 1 | al = 1; 0x00407a20 jmp 0x4062cc | goto label_3; | label_40: 0x00407a25 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407a29 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407a2d test ecx, ecx | | if (ecx != 0) { 0x00407a2f je 0x407a46 | 0x00407a31 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407a34 cdq | edx:eax = (int64_t) eax; 0x00407a35 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407a37 xor esi, esi | esi = 0; 0x00407a39 cmp edx, ecx | 0x00407a3b setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407a3f imul eax, ecx | eax *= ecx; 0x00407a42 add eax, edx | eax += edx; 0x00407a44 sub eax, esi | eax -= esi; | } 0x00407a46 test al, 3 | 0x00407a48 sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407a4c jmp 0x406368 | goto label_4; | label_50: 0x00407a51 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407a55 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407a59 test ecx, ecx | | if (ecx != 0) { 0x00407a5b je 0x407a72 | 0x00407a5d lea esi, [rcx + 2] | esi = rcx + 2; 0x00407a60 cdq | edx:eax = (int64_t) eax; 0x00407a61 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407a63 xor esi, esi | esi = 0; 0x00407a65 cmp edx, ecx | 0x00407a67 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407a6b imul eax, ecx | eax *= ecx; 0x00407a6e add eax, edx | eax += edx; 0x00407a70 sub eax, esi | eax -= esi; | } 0x00407a72 test al, 3 | 0x00407a74 sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407a78 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407a7d jne 0x406550 | goto label_5; | } 0x00407a83 jmp 0x40657e | goto label_6; | label_54: 0x00407a88 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407a8c mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407a90 test ecx, ecx | | if (ecx != 0) { 0x00407a92 je 0x407aa9 | 0x00407a94 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407a97 cdq | edx:eax = (int64_t) eax; 0x00407a98 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407a9a xor esi, esi | esi = 0; 0x00407a9c cmp edx, ecx | 0x00407a9e setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407aa2 imul eax, ecx | eax *= ecx; 0x00407aa5 add eax, edx | eax += edx; 0x00407aa7 sub eax, esi | eax -= esi; | } 0x00407aa9 test al, 3 | 0x00407aab sete r12b | r12b = ((al & 3) == 0) ? 1 : 0; 0x00407aaf cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407ab4 jne 0x4066b0 | goto label_7; | } 0x00407aba jmp 0x4066de | goto label_8; | label_58: 0x00407abf mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407ac3 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407ac7 test ecx, ecx | | if (ecx != 0) { 0x00407ac9 je 0x407ae0 | 0x00407acb lea esi, [rcx + 2] | esi = rcx + 2; 0x00407ace cdq | edx:eax = (int64_t) eax; 0x00407acf idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407ad1 xor esi, esi | esi = 0; 0x00407ad3 cmp edx, ecx | 0x00407ad5 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407ad9 imul eax, ecx | eax *= ecx; 0x00407adc add eax, edx | eax += edx; 0x00407ade sub eax, esi | eax -= esi; | } 0x00407ae0 test al, 3 | 0x00407ae2 sete r12b | r12b = ((al & 3) == 0) ? 1 : 0; 0x00407ae6 cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407aeb jne 0x406810 | goto label_9; | } 0x00407af1 jmp 0x40683e | goto label_10; | label_63: 0x00407af6 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407afa mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407afe test ecx, ecx | | if (ecx != 0) { 0x00407b00 je 0x407b17 | 0x00407b02 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407b05 cdq | edx:eax = (int64_t) eax; 0x00407b06 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407b08 xor esi, esi | esi = 0; 0x00407b0a cmp edx, ecx | 0x00407b0c setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407b10 imul eax, ecx | eax *= ecx; 0x00407b13 add eax, edx | eax += edx; 0x00407b15 sub eax, esi | eax -= esi; | } 0x00407b17 test al, 3 | 0x00407b19 sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407b1d cmp byte [rsp + 0x15], 0 | | if (*((rsp + 0x15)) != 0) { 0x00407b22 jne 0x406975 | goto label_11; | } 0x00407b28 jmp 0x4069a3 | goto label_12; | label_67: 0x00407b2d mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407b31 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407b35 test ecx, ecx | | if (ecx != 0) { 0x00407b37 je 0x407b4e | 0x00407b39 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407b3c cdq | edx:eax = (int64_t) eax; 0x00407b3d idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407b3f xor esi, esi | esi = 0; 0x00407b41 cmp edx, ecx | 0x00407b43 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407b47 imul eax, ecx | eax *= ecx; 0x00407b4a add eax, edx | eax += edx; 0x00407b4c sub eax, esi | eax -= esi; | } 0x00407b4e test al, 3 | 0x00407b50 sete r13b | r13b = ((al & 3) == 0) ? 1 : 0; 0x00407b54 mov eax, r13d | eax = r13d; 0x00407b57 and al, bl | al &= bl; 0x00407b59 cmp al, 1 | | if (al != 1) { 0x00407b5b jne 0x406aa2 | goto label_13; | } 0x00407b61 mov edi, 0x44f523 | 0x00407b66 mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x00407b6b mov esi, 0x2bf | esi = 0x2bf; 0x00407b70 xor eax, eax | eax = 0; 0x00407b72 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407b77 mov eax, dword [rip + 0x260e0b] | eax = (anonymous namespace)::testStatus; 0x00407b7d mov r13b, 1 | r13b = 1; 0x00407b80 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407b83 ja 0x406aa2 | goto label_13; | } 0x00407b89 inc eax | eax++; 0x00407b8b mov dword [rip + 0x260df7], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407b91 jmp 0x406aa2 | goto label_13; | label_46: 0x00407b96 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407b9a mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407b9e test ecx, ecx | | if (ecx != 0) { 0x00407ba0 je 0x407bb7 | 0x00407ba2 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407ba5 cdq | edx:eax = (int64_t) eax; 0x00407ba6 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407ba8 xor esi, esi | esi = 0; 0x00407baa cmp edx, ecx | 0x00407bac setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407bb0 imul eax, ecx | eax *= ecx; 0x00407bb3 add eax, edx | eax += edx; 0x00407bb5 sub eax, esi | eax -= esi; | } 0x00407bb7 test al, 3 | 0x00407bb9 sete r15b | r15b = ((al & 3) == 0) ? 1 : 0; 0x00407bbd mov eax, r15d | eax = r15d; 0x00407bc0 and al, r12b | al &= r12b; 0x00407bc3 cmp al, 1 | | if (al != 1) { 0x00407bc5 jne 0x40644c | goto label_14; | } 0x00407bcb mov edi, 0x44f523 | 0x00407bd0 mov edx, 0x44d5e3 | edx = "a1 || !enabled"; 0x00407bd5 mov esi, 0x2d1 | esi = 0x2d1; 0x00407bda xor eax, eax | eax = 0; 0x00407bdc call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407be1 mov eax, dword [rip + 0x260da1] | eax = (anonymous namespace)::testStatus; 0x00407be7 mov r15b, 1 | r15b = 1; 0x00407bea cmp eax, 0x64 | | if (eax > 0x64) { 0x00407bed ja 0x40644c | goto label_14; | } 0x00407bf3 inc eax | eax++; 0x00407bf5 mov dword [rip + 0x260d8d], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407bfb jmp 0x40644c | goto label_14; | label_105: 0x00407c00 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407c04 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407c08 test ecx, ecx | | if (ecx != 0) { 0x00407c0a je 0x407c21 | 0x00407c0c lea esi, [rcx + 2] | esi = rcx + 2; 0x00407c0f cdq | edx:eax = (int64_t) eax; 0x00407c10 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407c12 xor esi, esi | esi = 0; 0x00407c14 cmp edx, ecx | 0x00407c16 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407c1a imul eax, ecx | eax *= ecx; 0x00407c1d add eax, edx | eax += edx; 0x00407c1f sub eax, esi | eax -= esi; | } 0x00407c21 test al, 3 | 0x00407c23 sete al | al = ((al & 3) == 0) ? 1 : 0; 0x00407c26 mov dword [rsp + 0x28], eax | *((rsp + 0x28)) = eax; 0x00407c2a and al, r12b | al &= r12b; 0x00407c2d cmp al, 1 | | if (al != 1) { 0x00407c2f jne 0x4075f3 | goto label_15; | } 0x00407c35 mov edi, 0x44f523 | 0x00407c3a mov edx, 0x44d61f | edx = "b1 || !enabled"; 0x00407c3f mov esi, 0x2d9 | esi = 0x2d9; 0x00407c44 xor eax, eax | eax = 0; 0x00407c46 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407c4b mov eax, dword [rip + 0x260d37] | eax = (anonymous namespace)::testStatus; 0x00407c51 mov cl, 1 | cl = 1; 0x00407c53 mov dword [rsp + 0x28], ecx | *((rsp + 0x28)) = ecx; 0x00407c57 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407c5a ja 0x4075f3 | goto label_15; | } 0x00407c60 inc eax | eax++; 0x00407c62 mov dword [rip + 0x260d20], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407c68 jmp 0x4075f3 | goto label_15; | }