; assembly | /* r2dec pseudo code output */ | /* bdlde_base64encoder.t/assume @ 0x405f90 */ | #include | ; (fcn) sym.isState_BloombergLP::bdlde::Base64Encoder__int_ () | int32_t isState_BloombergLP::bdlde::Base64Encoder_int_ (int64_t arg2, char * arg1) { | uint32_t var_dh; | uint32_t var_eh; | uint32_t var_fh; | uint32_t var_10h; | int64_t var_17h; | int64_t var_18h; | int64_t var_19h; | int64_t var_1ah; | int64_t var_1bh; | uint32_t var_24h; | uint32_t var_28h; | int64_t var_2ch; | uint32_t var_30h; | uint32_t var_34h; | uint32_t var_38h; | uint32_t var_3ch; | int64_t var_43h; | int64_t var_44h; | rsi = arg2; | rdi = arg1; | /* isState(BloombergLP::bdlde::Base64Encoder*, int) */ 0x00405f90 push rbp | 0x00405f91 push r15 | 0x00405f93 push r14 | 0x00405f95 push r13 | 0x00405f97 push r12 | 0x00405f99 push rbx | 0x00405f9a sub rsp, 0x48 | 0x00405f9e mov ebp, esi | 0x00405fa0 mov r14, rdi | r14 = rdi; 0x00405fa3 test rdi, rdi | | if (rdi == 0) { 0x00405fa6 jne 0x405fd1 | 0x00405fa8 mov edi, 0x44f44e | 0x00405fad mov edx, 0x44d2bd | edx = "object"; 0x00405fb2 mov esi, 0x23c | esi = 0x23c; 0x00405fb7 xor eax, eax | eax = 0; 0x00405fb9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405fbe mov eax, dword [rip + 0x2629c4] | eax = (anonymous namespace)::testStatus; 0x00405fc4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405fc7 ja 0x405fd1 | goto label_16; | } 0x00405fc9 inc eax | eax++; 0x00405fcb mov dword [rip + 0x2629b7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_16: 0x00405fd1 test ebp, ebp | | if (ebp >= 0) { 0x00405fd3 js 0x405fe6 | 0x00405fd5 cmp ebp, 6 | | if (ebp < 6) { 0x00405fd8 jl 0x40600f | goto label_17; | } 0x00405fda mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405fdf mov edx, 0x44d2cf | edx = "state < NUM_STATES"; 0x00405fe4 jmp 0x405ff0 | | } else { 0x00405fe6 mov edi, 0x44f44e | 0x00405feb mov edx, 0x44d2c4 | edx = "0 <= state"; | } 0x00405ff0 mov esi, 0x23c | esi = 0x23c; 0x00405ff5 xor eax, eax | eax = 0; 0x00405ff7 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405ffc mov eax, dword [rip + 0x262986] | eax = (anonymous namespace)::testStatus; 0x00406002 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406005 ja 0x40600f | 0x00406007 inc eax | eax++; 0x00406009 mov dword [rip + 0x262979], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_17: 0x0040600f mov al, byte [rip + 0x26296c] | al = globalAssertsEnabled; 0x00406015 mov byte [rsp + 0xd], al | *((rsp + 0xd)) = al; 0x00406019 mov qword [rsp + 0x18], 0xffffffffffffffff | *((rsp + 0x18)) = 0xffffffffffffffff; 0x00406022 mov dword [rsp + 0x2c], 0xffffffff | *((rsp + 0x2c)) = 0xffffffff; 0x0040602a mov dword [rsp + 0x44], 0xffffffff | *((rsp + 0x44)) = 0xffffffff; 0x00406032 mov byte [rsp + 0x17], 0 | *((rsp + 0x17)) = 0; 0x00406037 cmp ebp, 5 | | if (ebp > 5) { 0x0040603a ja 0x4060fe | goto label_18; | } 0x00406040 mov eax, ebp | eax = ebp; | /* switch table (6 cases) at 0x449bc0 */ 0x00406042 jmp qword [rax*8 + 0x449bc0] | 0x00406049 mov bl, byte [r14] | bl = *(r14); 0x0040604c mov eax, ebx | eax = ebx; 0x0040604e cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406053 je 0x406088 | 0x00406055 mov eax, ebx | eax = ebx; 0x00406057 cmp bl, 0xff | | if (bl != 0xff) { 0x0040605a jne 0x406088 | goto label_19; | } 0x0040605c mov edi, 0x44f44e | 0x00406061 mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x00406066 mov esi, 0x24b | esi = 0x24b; 0x0040606b xor eax, eax | eax = 0; 0x0040606d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406072 mov eax, dword [rip + 0x262910] | eax = (anonymous namespace)::testStatus; 0x00406078 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040607b ja 0x406085 | 0x0040607d inc eax | eax++; 0x0040607f mov dword [rip + 0x262903], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406085 mov al, byte [r14] | al = *(r14); | } | label_19: 0x00406088 cmp al, 1 | 0x0040608a mov byte [rsp + 0x28], bl | *((rsp + 0x28)) = bl; | if (al == 1) { 0x0040608e jne 0x40609b | 0x00406090 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406095 je 0x407871 | goto label_20; | } | } 0x0040609b cmp byte [rsp + 0xd], 0 | 0x004060a0 setne r12b | r12b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x004060a4 xor eax, eax | eax = 0; | do { | label_0: 0x004060a6 mov dword [rsp + 0x24], eax | *((rsp + 0x24)) = eax; 0x004060aa mov bpl, byte [r14] | bpl = *(r14); 0x004060ad test r12b, r12b | | if (r12b != 0) { 0x004060b0 je 0x4060e1 | 0x004060b2 cmp bpl, 0xff | | if (bpl != 0xff) { 0x004060b6 jne 0x4060e1 | goto label_21; | } 0x004060b8 mov edi, 0x44f44e | 0x004060bd mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x004060c2 mov esi, 0x24d | esi = 0x24d; 0x004060c7 xor eax, eax | eax = 0; 0x004060c9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004060ce mov eax, dword [rip + 0x2628b4] | eax = (anonymous namespace)::testStatus; 0x004060d4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004060d7 ja 0x4060e1 | goto label_21; | } 0x004060d9 inc eax | eax++; 0x004060db mov dword [rip + 0x2628a7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_21: 0x004060e1 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x004060e6 je 0x4064a6 | 0x004060ec xor ebx, ebx | ebx = 0; 0x004060ee cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) == 0) { 0x004060f3 jne 0x4064b4 | 0x004060f9 jmp 0x4064e1 | goto label_22; | label_18: 0x004060fe xor ebx, ebx | ebx = 0; 0x00406100 mov edi, 0x44f44e | 0x00406105 mov edx, 0x44d50f | edx = "\"Unknown State\" && 0"; 0x0040610a mov esi, 0x2ea | esi = 0x2ea; 0x0040610f xor eax, eax | eax = 0; 0x00406111 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406116 mov eax, dword [rip + 0x26286c] | eax = (anonymous namespace)::testStatus; 0x0040611c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040611f ja 0x407860 | goto label_23; | } 0x00406125 inc eax | eax++; 0x00406127 mov dword [rip + 0x26285b], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x0040612d xor ebx, ebx | ebx = 0; 0x0040612f jmp 0x407860 | goto label_23; 0x00406134 mov bpl, byte [r14] | bpl = *(r14); 0x00406137 mov eax, ebp | eax = ebp; 0x00406139 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040613e je 0x406174 | 0x00406140 mov eax, ebp | eax = ebp; 0x00406142 cmp bpl, 0xff | | if (bpl != 0xff) { 0x00406146 jne 0x406174 | goto label_24; | } 0x00406148 mov edi, 0x44f44e | 0x0040614d mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x00406152 mov esi, 0x265 | esi = 0x265; 0x00406157 xor eax, eax | eax = 0; 0x00406159 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040615e mov eax, dword [rip + 0x262824] | eax = (anonymous namespace)::testStatus; 0x00406164 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406167 ja 0x406171 | 0x00406169 inc eax | eax++; 0x0040616b mov dword [rip + 0x262817], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406171 mov al, byte [r14] | al = *(r14); | } | label_24: 0x00406174 cmp al, 1 | | if (al == 1) { 0x00406176 jne 0x406183 | 0x00406178 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x0040617d je 0x4078e3 | goto label_25; | } | } 0x00406183 cmp byte [rsp + 0xd], 0 | 0x00406188 setne r13b | r13b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x0040618c xor eax, eax | eax = 0; | label_1: 0x0040618e mov dword [rsp + 0x28], eax | *((rsp + 0x28)) = eax; 0x00406192 mov bl, byte [r14] | bl = *(r14); 0x00406195 test r13b, r13b | | if (r13b != 0) { 0x00406198 je 0x4061c8 | 0x0040619a cmp bl, 0xff | | if (bl != 0xff) { 0x0040619d jne 0x4061c8 | goto label_26; | } 0x0040619f mov edi, 0x44f44e | 0x004061a4 mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x004061a9 mov esi, 0x267 | esi = 0x267; 0x004061ae xor eax, eax | eax = 0; 0x004061b0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004061b5 mov eax, dword [rip + 0x2627cd] | eax = (anonymous namespace)::testStatus; 0x004061bb cmp eax, 0x64 | | if (eax > 0x64) { 0x004061be ja 0x4061c8 | goto label_26; | } 0x004061c0 inc eax | eax++; 0x004061c2 mov dword [rip + 0x2627c0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_26: 0x004061c8 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004061cd je 0x4065df | goto label_27; | } 0x004061d3 xor ecx, ecx | ecx = 0; 0x004061d5 jmp 0x40661a | goto label_28; 0x004061da mov bpl, byte [r14] | bpl = *(r14); 0x004061dd mov eax, ebp | eax = ebp; 0x004061df cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004061e4 je 0x40621a | 0x004061e6 mov eax, ebp | eax = ebp; 0x004061e8 cmp bpl, 0xff | | if (bpl != 0xff) { 0x004061ec jne 0x40621a | goto label_29; | } 0x004061ee mov edi, 0x44f44e | 0x004061f3 mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x004061f8 mov esi, 0x280 | esi = 0x280; 0x004061fd xor eax, eax | eax = 0; 0x004061ff call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406204 mov eax, dword [rip + 0x26277e] | eax = (anonymous namespace)::testStatus; 0x0040620a cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040620d ja 0x406217 | 0x0040620f inc eax | eax++; 0x00406211 mov dword [rip + 0x262771], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406217 mov al, byte [r14] | al = *(r14); | } | label_29: 0x0040621a cmp al, 1 | | if (al == 1) { 0x0040621c jne 0x406229 | 0x0040621e cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406223 je 0x407955 | goto label_30; | } | } 0x00406229 cmp byte [rsp + 0xd], 0 | 0x0040622e setne r13b | r13b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x00406232 xor eax, eax | eax = 0; | label_2: 0x00406234 mov dword [rsp + 0x28], eax | *((rsp + 0x28)) = eax; 0x00406238 mov bl, byte [r14] | bl = *(r14); 0x0040623b test r13b, r13b | | if (r13b != 0) { 0x0040623e je 0x40626e | 0x00406240 cmp bl, 0xff | | if (bl != 0xff) { 0x00406243 jne 0x40626e | goto label_31; | } 0x00406245 mov edi, 0x44f44e | 0x0040624a mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x0040624f mov esi, 0x282 | esi = 0x282; 0x00406254 xor eax, eax | eax = 0; 0x00406256 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040625b mov eax, dword [rip + 0x262727] | eax = (anonymous namespace)::testStatus; 0x00406261 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406264 ja 0x40626e | goto label_31; | } 0x00406266 inc eax | eax++; 0x00406268 mov dword [rip + 0x26271a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_31: 0x0040626e cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406273 je 0x40673f | goto label_32; | } 0x00406279 xor ecx, ecx | ecx = 0; 0x0040627b jmp 0x40677a | goto label_33; 0x00406280 mov r13b, byte [r14] | r13b = *(r14); 0x00406283 mov eax, r13d | eax = r13d; 0x00406286 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040628b je 0x4062c2 | 0x0040628d mov eax, r13d | eax = r13d; 0x00406290 cmp r13b, 0xff | | if (r13b != 0xff) { 0x00406294 jne 0x4062c2 | goto label_34; | } 0x00406296 mov edi, 0x44f44e | 0x0040629b mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x004062a0 mov esi, 0x29b | esi = 0x29b; 0x004062a5 xor eax, eax | eax = 0; 0x004062a7 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004062ac mov eax, dword [rip + 0x2626d6] | eax = (anonymous namespace)::testStatus; 0x004062b2 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004062b5 ja 0x4062bf | 0x004062b7 inc eax | eax++; 0x004062b9 mov dword [rip + 0x2626c9], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004062bf mov al, byte [r14] | al = *(r14); | } | label_34: 0x004062c2 cmp al, 1 | | if (al == 1) { 0x004062c4 jne 0x4062d1 | 0x004062c6 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004062cb je 0x4079c7 | goto label_35; | } | } 0x004062d1 cmp byte [rsp + 0xd], 0 | 0x004062d6 setne r12b | r12b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x004062da xor eax, eax | eax = 0; | label_3: 0x004062dc mov dword [rsp + 0x28], eax | *((rsp + 0x28)) = eax; 0x004062e0 mov bl, byte [r14] | bl = *(r14); 0x004062e3 test r12b, r12b | | if (r12b != 0) { 0x004062e6 je 0x406316 | 0x004062e8 cmp bl, 0xff | | if (bl != 0xff) { 0x004062eb jne 0x406316 | goto label_36; | } 0x004062ed mov edi, 0x44f44e | 0x004062f2 mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x004062f7 mov esi, 0x29d | esi = 0x29d; 0x004062fc xor eax, eax | eax = 0; 0x004062fe call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406303 mov eax, dword [rip + 0x26267f] | eax = (anonymous namespace)::testStatus; 0x00406309 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040630c ja 0x406316 | goto label_36; | } 0x0040630e inc eax | eax++; 0x00406310 mov dword [rip + 0x262672], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_36: 0x00406316 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x0040631b je 0x40689f | goto label_37; | } 0x00406321 xor ecx, ecx | ecx = 0; 0x00406323 jmp 0x4068da | goto label_38; 0x00406328 mov bl, byte [r14] | bl = *(r14); 0x0040632b mov eax, ebx | eax = ebx; 0x0040632d cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406332 je 0x406367 | 0x00406334 mov eax, ebx | eax = ebx; 0x00406336 cmp bl, 0xff | | if (bl != 0xff) { 0x00406339 jne 0x406367 | goto label_39; | } 0x0040633b mov edi, 0x44f44e | 0x00406340 mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x00406345 mov esi, 0x2b6 | esi = 0x2b6; 0x0040634a xor eax, eax | eax = 0; 0x0040634c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406351 mov eax, dword [rip + 0x262631] | eax = (anonymous namespace)::testStatus; 0x00406357 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040635a ja 0x406364 | 0x0040635c inc eax | eax++; 0x0040635e mov dword [rip + 0x262624], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406364 mov al, byte [r14] | al = *(r14); | } | label_39: 0x00406367 cmp al, 1 | | if (al == 1) { 0x00406369 jne 0x406376 | 0x0040636b cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406370 je 0x407a39 | goto label_40; | } | } 0x00406376 xor ebp, ebp | ebp = 0; | label_4: 0x00406378 mov byte [rsp + 0x28], bl | *((rsp + 0x28)) = bl; 0x0040637c cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406381 je 0x4063b1 | 0x00406383 test bpl, bpl | | if (bpl != 0) { 0x00406386 jne 0x4063b1 | goto label_41; | } 0x00406388 mov edi, 0x44f44e | 0x0040638d mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x00406392 mov esi, 0x2b7 | esi = 0x2b7; 0x00406397 xor eax, eax | eax = 0; 0x00406399 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040639e mov eax, dword [rip + 0x2625e4] | eax = (anonymous namespace)::testStatus; 0x004063a4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004063a7 ja 0x4063b1 | goto label_41; | } 0x004063a9 inc eax | eax++; 0x004063ab mov dword [rip + 0x2625d7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_41: 0x004063b1 cmp byte [rsp + 0xd], 0 | 0x004063b6 setne bl | bl = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x004063b9 mov al, byte [r14] | al = *(r14); 0x004063bc mov byte [rsp + 0x24], al | *((rsp + 0x24)) = al; 0x004063c0 cmp al, 0xff | | if (al == 0xff) { 0x004063c2 jne 0x4063f1 | 0x004063c4 test bl, bl | | if (bl == 0) { 0x004063c6 je 0x4063f1 | goto label_42; | } 0x004063c8 mov edi, 0x44f44e | 0x004063cd mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x004063d2 mov esi, 0x2b8 | esi = 0x2b8; 0x004063d7 xor eax, eax | eax = 0; 0x004063d9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004063de mov eax, dword [rip + 0x2625a4] | eax = (anonymous namespace)::testStatus; 0x004063e4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004063e7 ja 0x4063f1 | goto label_42; | } 0x004063e9 inc eax | eax++; 0x004063eb mov dword [rip + 0x262597], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_42: 0x004063f1 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004063f6 je 0x406a04 | goto label_43; | } 0x004063fc xor ecx, ecx | ecx = 0; 0x004063fe jmp 0x406a3e | goto label_44; 0x00406403 cmp byte [rsp + 0xd], 0 | 0x00406408 setne r12b | r12b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x0040640c mov bpl, byte [r14] | bpl = *(r14); 0x0040640f mov eax, ebp | eax = ebp; 0x00406411 cmp bpl, 0xff | | if (bpl != 0xff) { 0x00406415 je 0x40644a | 0x00406417 mov eax, ebp | eax = ebp; 0x00406419 test r12b, r12b | | if (r12b == 0) { 0x0040641c je 0x40644a | goto label_45; | } 0x0040641e mov edi, 0x44f44e | 0x00406423 mov edx, 0x44d524 | edx = "a0 || !enabled"; 0x00406428 mov esi, 0x2d0 | esi = 0x2d0; 0x0040642d xor eax, eax | eax = 0; 0x0040642f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406434 mov eax, dword [rip + 0x26254e] | eax = (anonymous namespace)::testStatus; 0x0040643a cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040643d ja 0x406447 | 0x0040643f inc eax | eax++; 0x00406441 mov dword [rip + 0x262541], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406447 mov al, byte [r14] | al = *(r14); | } | label_45: 0x0040644a cmp al, 1 | | if (al == 1) { 0x0040644c jne 0x406459 | 0x0040644e cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406453 je 0x407bb0 | goto label_46; | } | } 0x00406459 xor ebx, ebx | ebx = 0; | label_14: 0x0040645b mov r13b, byte [r14] | r13b = *(r14); 0x0040645e cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406463 je 0x406494 | 0x00406465 cmp r13b, 0xff | | if (r13b == 0xff) { 0x00406469 je 0x406494 | goto label_47; | } 0x0040646b mov edi, 0x44f44e | 0x00406470 mov edx, 0x44d542 | edx = "a2 || !enabled"; 0x00406475 mov esi, 0x2d2 | esi = 0x2d2; 0x0040647a xor eax, eax | eax = 0; 0x0040647c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406481 mov eax, dword [rip + 0x262501] | eax = (anonymous namespace)::testStatus; 0x00406487 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040648a ja 0x406494 | goto label_47; | } 0x0040648c inc eax | eax++; 0x0040648e mov dword [rip + 0x2624f4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_47: 0x00406494 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406499 je 0x407553 | goto label_48; | } 0x0040649f xor ecx, ecx | ecx = 0; 0x004064a1 jmp 0x40758e | | } else { 0x004064a6 cmp byte [r14], 0 | 0x004064aa sete bl | bl = (*(r14) == 0) ? 1 : 0; 0x004064ad cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) == 0) { 0x004064b2 je 0x4064e1 | goto label_22; | } | } 0x004064b4 test bl, bl | | if (bl == 0) { 0x004064b6 jne 0x4064e1 | 0x004064b8 mov edi, 0x44f44e | 0x004064bd mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x004064c2 mov esi, 0x24e | esi = 0x24e; 0x004064c7 xor eax, eax | eax = 0; 0x004064c9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004064ce mov eax, dword [rip + 0x2624b4] | eax = (anonymous namespace)::testStatus; 0x004064d4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004064d7 ja 0x4064e1 | goto label_22; | } 0x004064d9 inc eax | eax++; 0x004064db mov dword [rip + 0x2624a7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_22: 0x004064e1 mov dword [rsp + 0x30], ebx | *((rsp + 0x30)) = ebx; 0x004064e5 lea rsi, [rsp + 0x18] | 0x004064ea lea rdx, [rsp + 0x2c] | 0x004064ef mov rdi, r14 | 0x004064f2 mov ecx, 0xffffffff | 0x004064f7 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x18, rsp + 0x2c, 0xffffffff); 0x004064fc mov dword [rsp + 0x10], eax | *((rsp + 0x10)) = eax; 0x00406500 mov bl, byte [r14] | bl = *(r14); 0x00406503 mov eax, ebx | eax = ebx; 0x00406505 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040650a je 0x40653f | 0x0040650c mov eax, ebx | eax = ebx; 0x0040650e cmp bl, 0xff | | if (bl != 0xff) { 0x00406511 jne 0x40653f | goto label_49; | } 0x00406513 mov edi, 0x44f44e | 0x00406518 mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x0040651d mov esi, 0x253 | esi = 0x253; 0x00406522 xor eax, eax | eax = 0; 0x00406524 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406529 mov eax, dword [rip + 0x262459] | eax = (anonymous namespace)::testStatus; 0x0040652f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406532 ja 0x40653c | 0x00406534 inc eax | eax++; 0x00406536 mov dword [rip + 0x26244c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040653c mov al, byte [r14] | al = *(r14); | } | label_49: 0x0040653f cmp al, 1 | 0x00406541 mov byte [rsp + 0x3c], bpl | *((rsp + 0x3c)) = bpl; 0x00406546 mov byte [rsp + 0xe], bl | *((rsp + 0xe)) = bl; | if (al == 1) { 0x0040654a jne 0x406557 | 0x0040654c cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406551 je 0x407a66 | goto label_50; | } | } 0x00406557 xor ebp, ebp | ebp = 0; 0x00406559 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040655e je 0x40658e | | label_5: 0x00406560 test bpl, bpl | | if (bpl != 0) { 0x00406563 jne 0x40658e | goto label_6; | } 0x00406565 mov edi, 0x44f44e | 0x0040656a mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x0040656f mov esi, 0x254 | esi = 0x254; 0x00406574 xor eax, eax | eax = 0; 0x00406576 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040657b mov eax, dword [rip + 0x262407] | eax = (anonymous namespace)::testStatus; 0x00406581 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406584 ja 0x40658e | goto label_6; | } 0x00406586 inc eax | eax++; 0x00406588 mov dword [rip + 0x2623fa], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_6: 0x0040658e mov al, byte [r14] | al = *(r14); 0x00406591 mov byte [rsp + 0x38], al | *((rsp + 0x38)) = al; 0x00406595 cmp al, 0xff | 0x00406597 setne al | al = (al != 0xff) ? 1 : 0; 0x0040659a mov ecx, r12d | ecx = r12d; 0x0040659d xor cl, 1 | cl ^= 1; 0x004065a0 or cl, al | cl |= al; | if (cl == 0) { 0x004065a2 jne 0x4065cd | 0x004065a4 mov edi, 0x44f44e | 0x004065a9 mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x004065ae mov esi, 0x255 | esi = 0x255; 0x004065b3 xor eax, eax | eax = 0; 0x004065b5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004065ba mov eax, dword [rip + 0x2623c8] | eax = (anonymous namespace)::testStatus; 0x004065c0 cmp eax, 0x64 | | if (eax > 0x64) { 0x004065c3 ja 0x4065cd | goto label_51; | } 0x004065c5 inc eax | eax++; 0x004065c7 mov dword [rip + 0x2623bb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_51: 0x004065cd cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x004065d2 je 0x406b02 | 0x004065d8 xor ecx, ecx | ecx = 0; 0x004065da jmp 0x406b3d | goto label_52; | label_27: 0x004065df cmp byte [r14], 0 | 0x004065e3 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x004065e6 mov eax, r13d | eax = r13d; 0x004065e9 and al, cl | al &= cl; 0x004065eb cmp al, 1 | | if (al == 1) { 0x004065ed jne 0x40661a | 0x004065ef mov edi, 0x44f44e | 0x004065f4 mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x004065f9 mov esi, 0x268 | esi = 0x268; 0x004065fe xor eax, eax | eax = 0; 0x00406600 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406605 mov eax, dword [rip + 0x26237d] | eax = (anonymous namespace)::testStatus; 0x0040660b mov cl, 1 | cl = 1; 0x0040660d cmp eax, 0x64 | | if (eax > 0x64) { 0x00406610 ja 0x40661a | goto label_28; | } 0x00406612 inc eax | eax++; 0x00406614 mov dword [rip + 0x26236e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x0040661a mov dword [rsp + 0x3c], ecx | *((rsp + 0x3c)) = ecx; 0x0040661e mov byte [rsp + 0x24], bl | *((rsp + 0x24)) = bl; 0x00406622 mov byte [rsp + 0x10], bpl | *((rsp + 0x10)) = bpl; 0x00406627 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040662e lea rbp, [rsp + 0x18] | rbp = rsp + 0x18; 0x00406633 lea rbx, [rsp + 0x2c] | rbx = rsp + 0x2c; 0x00406638 lea rcx, [rsp + 0x44] | 0x0040663d lea r8, [rsp + 0x17] | 0x00406642 mov rdi, r14 | 0x00406645 mov rsi, rbp | 0x00406648 mov rdx, rbx | 0x0040664b mov r9, r8 | 0x0040664e call 0x421500 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbp, rbx, rsp + 0x44, rsp + 0x17, r8); 0x00406653 mov rdi, r14 | 0x00406656 mov rsi, rbp | 0x00406659 mov rdx, rbx | 0x0040665c mov ecx, 0xffffffff | 0x00406661 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbp, rbx, 0xffffffff); 0x00406666 mov ebp, eax | 0x00406668 mov bl, byte [r14] | bl = *(r14); 0x0040666b mov eax, ebx | eax = ebx; 0x0040666d cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406672 je 0x4066a7 | 0x00406674 mov eax, ebx | eax = ebx; 0x00406676 cmp bl, 0xff | | if (bl != 0xff) { 0x00406679 jne 0x4066a7 | goto label_53; | } 0x0040667b mov edi, 0x44f44e | 0x00406680 mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x00406685 mov esi, 0x26e | esi = 0x26e; 0x0040668a xor eax, eax | eax = 0; 0x0040668c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406691 mov eax, dword [rip + 0x2622f1] | eax = (anonymous namespace)::testStatus; 0x00406697 cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040669a ja 0x4066a4 | 0x0040669c inc eax | eax++; 0x0040669e mov dword [rip + 0x2622e4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004066a4 mov al, byte [r14] | al = *(r14); | } | label_53: 0x004066a7 cmp al, 1 | | if (al == 1) { 0x004066a9 jne 0x4066b6 | 0x004066ab cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004066b0 je 0x407a9e | goto label_54; | } | } 0x004066b6 xor r12d, r12d | r12d = 0; 0x004066b9 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004066be je 0x4066ee | | label_7: 0x004066c0 test r12b, r12b | | if (r12b != 0) { 0x004066c3 jne 0x4066ee | goto label_8; | } 0x004066c5 mov edi, 0x44f44e | 0x004066ca mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x004066cf mov esi, 0x26f | esi = 0x26f; 0x004066d4 xor eax, eax | eax = 0; 0x004066d6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004066db mov eax, dword [rip + 0x2622a7] | eax = (anonymous namespace)::testStatus; 0x004066e1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004066e4 ja 0x4066ee | goto label_8; | } 0x004066e6 inc eax | eax++; 0x004066e8 mov dword [rip + 0x26229a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_8: 0x004066ee mov al, byte [r14] | al = *(r14); 0x004066f1 mov byte [rsp + 0x38], al | *((rsp + 0x38)) = al; 0x004066f5 cmp al, 0xff | 0x004066f7 setne al | al = (al != 0xff) ? 1 : 0; 0x004066fa mov ecx, r13d | ecx = r13d; 0x004066fd xor cl, 1 | cl ^= 1; 0x00406700 or cl, al | cl |= al; | if (cl == 0) { 0x00406702 jne 0x40672d | 0x00406704 mov edi, 0x44f44e | 0x00406709 mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x0040670e mov esi, 0x270 | esi = 0x270; 0x00406713 xor eax, eax | eax = 0; 0x00406715 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040671a mov eax, dword [rip + 0x262268] | eax = (anonymous namespace)::testStatus; 0x00406720 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406723 ja 0x40672d | goto label_55; | } 0x00406725 inc eax | eax++; 0x00406727 mov dword [rip + 0x26225b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_55: 0x0040672d cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x00406732 je 0x406d05 | 0x00406738 xor ecx, ecx | ecx = 0; 0x0040673a jmp 0x406d40 | goto label_56; | label_32: 0x0040673f cmp byte [r14], 0 | 0x00406743 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406746 mov eax, r13d | eax = r13d; 0x00406749 and al, cl | al &= cl; 0x0040674b cmp al, 1 | | if (al == 1) { 0x0040674d jne 0x40677a | 0x0040674f mov edi, 0x44f44e | 0x00406754 mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x00406759 mov esi, 0x283 | esi = 0x283; 0x0040675e xor eax, eax | eax = 0; 0x00406760 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406765 mov eax, dword [rip + 0x26221d] | eax = (anonymous namespace)::testStatus; 0x0040676b mov cl, 1 | cl = 1; 0x0040676d cmp eax, 0x64 | | if (eax > 0x64) { 0x00406770 ja 0x40677a | goto label_33; | } 0x00406772 inc eax | eax++; 0x00406774 mov dword [rip + 0x26220e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x0040677a mov dword [rsp + 0x3c], ecx | *((rsp + 0x3c)) = ecx; 0x0040677e mov byte [rsp + 0x24], bl | *((rsp + 0x24)) = bl; 0x00406782 mov byte [rsp + 0x10], bpl | *((rsp + 0x10)) = bpl; 0x00406787 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040678e lea rbx, [rsp + 0x18] | rbx = rsp + 0x18; 0x00406793 lea rbp, [rsp + 0x2c] | rbp = rsp + 0x2c; 0x00406798 lea rcx, [rsp + 0x44] | 0x0040679d lea r8, [rsp + 0x17] | 0x004067a2 mov rdi, r14 | 0x004067a5 mov rsi, rbx | 0x004067a8 mov rdx, rbp | 0x004067ab mov r9, r8 | 0x004067ae call 0x421500 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbx, rbp, rsp + 0x44, rsp + 0x17, r8); 0x004067b3 mov rdi, r14 | 0x004067b6 mov rsi, rbx | 0x004067b9 mov rdx, rbp | 0x004067bc mov ecx, 0xffffffff | 0x004067c1 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbx, rbp, 0xffffffff); 0x004067c6 mov ebp, eax | 0x004067c8 mov bl, byte [r14] | bl = *(r14); 0x004067cb mov eax, ebx | eax = ebx; 0x004067cd cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004067d2 je 0x406807 | 0x004067d4 mov eax, ebx | eax = ebx; 0x004067d6 cmp bl, 0xff | | if (bl != 0xff) { 0x004067d9 jne 0x406807 | goto label_57; | } 0x004067db mov edi, 0x44f44e | 0x004067e0 mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x004067e5 mov esi, 0x289 | esi = 0x289; 0x004067ea xor eax, eax | eax = 0; 0x004067ec call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004067f1 mov eax, dword [rip + 0x262191] | eax = (anonymous namespace)::testStatus; 0x004067f7 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004067fa ja 0x406804 | 0x004067fc inc eax | eax++; 0x004067fe mov dword [rip + 0x262184], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406804 mov al, byte [r14] | al = *(r14); | } | label_57: 0x00406807 cmp al, 1 | | if (al == 1) { 0x00406809 jne 0x406816 | 0x0040680b cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406810 je 0x407ad6 | goto label_58; | } | } 0x00406816 xor r12d, r12d | r12d = 0; 0x00406819 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040681e je 0x40684e | | label_9: 0x00406820 test r12b, r12b | | if (r12b != 0) { 0x00406823 jne 0x40684e | goto label_10; | } 0x00406825 mov edi, 0x44f44e | 0x0040682a mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x0040682f mov esi, 0x28a | esi = 0x28a; 0x00406834 xor eax, eax | eax = 0; 0x00406836 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040683b mov eax, dword [rip + 0x262147] | eax = (anonymous namespace)::testStatus; 0x00406841 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406844 ja 0x40684e | goto label_10; | } 0x00406846 inc eax | eax++; 0x00406848 mov dword [rip + 0x26213a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x0040684e mov al, byte [r14] | al = *(r14); 0x00406851 mov byte [rsp + 0x38], al | *((rsp + 0x38)) = al; 0x00406855 cmp al, 0xff | 0x00406857 setne al | al = (al != 0xff) ? 1 : 0; 0x0040685a mov ecx, r13d | ecx = r13d; 0x0040685d xor cl, 1 | cl ^= 1; 0x00406860 or cl, al | cl |= al; | if (cl == 0) { 0x00406862 jne 0x40688d | 0x00406864 mov edi, 0x44f44e | 0x00406869 mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x0040686e mov esi, 0x28b | esi = 0x28b; 0x00406873 xor eax, eax | eax = 0; 0x00406875 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040687a mov eax, dword [rip + 0x262108] | eax = (anonymous namespace)::testStatus; 0x00406880 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406883 ja 0x40688d | goto label_59; | } 0x00406885 inc eax | eax++; 0x00406887 mov dword [rip + 0x2620fb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_59: 0x0040688d cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406892 je 0x406f16 | goto label_60; | } 0x00406898 xor ecx, ecx | ecx = 0; 0x0040689a jmp 0x406f51 | goto label_61; | label_37: 0x0040689f cmp byte [r14], 0 | 0x004068a3 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x004068a6 mov eax, r12d | eax = r12d; 0x004068a9 and al, cl | al &= cl; 0x004068ab cmp al, 1 | | if (al == 1) { 0x004068ad jne 0x4068da | 0x004068af mov edi, 0x44f44e | 0x004068b4 mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x004068b9 mov esi, 0x29e | esi = 0x29e; 0x004068be xor eax, eax | eax = 0; 0x004068c0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004068c5 mov eax, dword [rip + 0x2620bd] | eax = (anonymous namespace)::testStatus; 0x004068cb mov cl, 1 | cl = 1; 0x004068cd cmp eax, 0x64 | | if (eax > 0x64) { 0x004068d0 ja 0x4068da | goto label_38; | } 0x004068d2 inc eax | eax++; 0x004068d4 mov dword [rip + 0x2620ae], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_38: 0x004068da mov dword [rsp + 0x3c], ecx | *((rsp + 0x3c)) = ecx; 0x004068de mov byte [rsp + 0x24], bl | *((rsp + 0x24)) = bl; 0x004068e2 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004068e9 lea rbx, [rsp + 0x18] | rbx = rsp + 0x18; 0x004068ee lea rbp, [rsp + 0x2c] | rbp = rsp + 0x2c; 0x004068f3 lea rcx, [rsp + 0x44] | 0x004068f8 lea r8, [rsp + 0x17] | 0x004068fd mov rdi, r14 | 0x00406900 mov rsi, rbx | 0x00406903 mov rdx, rbp | 0x00406906 mov r9, r8 | 0x00406909 call 0x421500 | intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r14, rbx, rbp, rsp + 0x44, rsp + 0x17, r8); 0x0040690e mov rdi, r14 | 0x00406911 mov rsi, rbx | 0x00406914 mov rdx, rbp | 0x00406917 mov ecx, 0xffffffff | 0x0040691c call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rbx, rbp, 0xffffffff); 0x00406921 mov dword [rsp + 0x10], eax | *((rsp + 0x10)) = eax; 0x00406925 mov bl, byte [r14] | bl = *(r14); 0x00406928 mov eax, ebx | eax = ebx; 0x0040692a cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040692f je 0x406964 | 0x00406931 mov eax, ebx | eax = ebx; 0x00406933 cmp bl, 0xff | | if (bl != 0xff) { 0x00406936 jne 0x406964 | goto label_62; | } 0x00406938 mov edi, 0x44f44e | 0x0040693d mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x00406942 mov esi, 0x2a4 | esi = 0x2a4; 0x00406947 xor eax, eax | eax = 0; 0x00406949 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040694e mov eax, dword [rip + 0x262034] | eax = (anonymous namespace)::testStatus; 0x00406954 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406957 ja 0x406961 | 0x00406959 inc eax | eax++; 0x0040695b mov dword [rip + 0x262027], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406961 mov al, byte [r14] | al = *(r14); | } | label_62: 0x00406964 mov byte [rsp + 0x38], bl | *((rsp + 0x38)) = bl; 0x00406968 cmp al, 1 | 0x0040696a mov byte [rsp + 0xe], r13b | *((rsp + 0xe)) = r13b; | if (al == 1) { 0x0040696f jne 0x40697c | 0x00406971 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406976 je 0x407b0e | goto label_63; | } | } 0x0040697c xor ebp, ebp | ebp = 0; 0x0040697e cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406983 je 0x4069b3 | | label_11: 0x00406985 test bpl, bpl | | if (bpl != 0) { 0x00406988 jne 0x4069b3 | goto label_12; | } 0x0040698a mov edi, 0x44f44e | 0x0040698f mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x00406994 mov esi, 0x2a5 | esi = 0x2a5; 0x00406999 xor eax, eax | eax = 0; 0x0040699b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004069a0 mov eax, dword [rip + 0x261fe2] | eax = (anonymous namespace)::testStatus; 0x004069a6 cmp eax, 0x64 | | if (eax > 0x64) { 0x004069a9 ja 0x4069b3 | goto label_12; | } 0x004069ab inc eax | eax++; 0x004069ad mov dword [rip + 0x261fd5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_12: 0x004069b3 mov al, byte [r14] | al = *(r14); 0x004069b6 mov byte [rsp + 0xf], al | *((rsp + 0xf)) = al; 0x004069ba cmp al, 0xff | 0x004069bc setne al | al = (al != 0xff) ? 1 : 0; 0x004069bf mov ecx, r12d | ecx = r12d; 0x004069c2 xor cl, 1 | cl ^= 1; 0x004069c5 or cl, al | cl |= al; | if (cl == 0) { 0x004069c7 jne 0x4069f2 | 0x004069c9 mov edi, 0x44f44e | 0x004069ce mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x004069d3 mov esi, 0x2a6 | esi = 0x2a6; 0x004069d8 xor eax, eax | eax = 0; 0x004069da call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004069df mov eax, dword [rip + 0x261fa3] | eax = (anonymous namespace)::testStatus; 0x004069e5 cmp eax, 0x64 | | if (eax > 0x64) { 0x004069e8 ja 0x4069f2 | goto label_64; | } 0x004069ea inc eax | eax++; 0x004069ec mov dword [rip + 0x261f96], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_64: 0x004069f2 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x004069f7 je 0x407138 | goto label_65; | } 0x004069fd xor ecx, ecx | ecx = 0; 0x004069ff jmp 0x407173 | goto label_66; | label_43: 0x00406a04 cmp byte [r14], 0 | 0x00406a08 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406a0b mov eax, ecx | eax = ecx; 0x00406a0d and al, bl | al &= bl; 0x00406a0f cmp al, 1 | | if (al == 1) { 0x00406a11 jne 0x406a3e | 0x00406a13 mov edi, 0x44f44e | 0x00406a18 mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x00406a1d mov esi, 0x2b9 | esi = 0x2b9; 0x00406a22 xor eax, eax | eax = 0; 0x00406a24 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406a29 mov eax, dword [rip + 0x261f59] | eax = (anonymous namespace)::testStatus; 0x00406a2f mov cl, 1 | cl = 1; 0x00406a31 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406a34 ja 0x406a3e | goto label_44; | } 0x00406a36 inc eax | eax++; 0x00406a38 mov dword [rip + 0x261f4a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_44: 0x00406a3e mov dword [rsp + 0x3c], ecx | *((rsp + 0x3c)) = ecx; 0x00406a42 lea rsi, [rsp + 0x18] | 0x00406a47 lea rdx, [rsp + 0x2c] | 0x00406a4c mov rdi, r14 | 0x00406a4f mov ecx, 0xffffffff | 0x00406a54 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x18, rsp + 0x2c, 0xffffffff); 0x00406a59 mov r12d, eax | r12d = eax; 0x00406a5c mov dl, byte [r14] | dl = *(r14); 0x00406a5f cmp dl, 0xff | 0x00406a62 sete al | al = (dl == 0xff) ? 1 : 0; 0x00406a65 mov ecx, ebx | ecx = ebx; 0x00406a67 xor cl, 1 | cl ^= 1; 0x00406a6a or cl, al | cl |= al; 0x00406a6c mov byte [rsp + 0xe], dl | *((rsp + 0xe)) = dl; 0x00406a70 mov eax, edx | eax = edx; | if (cl == 0) { 0x00406a72 jne 0x406aa0 | 0x00406a74 mov edi, 0x44f44e | 0x00406a79 mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x00406a7e mov esi, 0x2be | esi = 0x2be; 0x00406a83 xor eax, eax | eax = 0; 0x00406a85 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406a8a mov eax, dword [rip + 0x261ef8] | eax = (anonymous namespace)::testStatus; 0x00406a90 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00406a93 ja 0x406a9d | 0x00406a95 inc eax | eax++; 0x00406a97 mov dword [rip + 0x261eeb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00406a9d mov al, byte [r14] | al = *(r14); | } 0x00406aa0 cmp al, 1 | | if (al == 1) { 0x00406aa2 jne 0x406aaf | 0x00406aa4 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x00406aa9 je 0x407b46 | goto label_67; | } | } 0x00406aaf xor r13d, r13d | r13d = 0; | label_13: 0x00406ab2 mov al, byte [r14] | al = *(r14); 0x00406ab5 mov byte [rsp + 0x10], al | *((rsp + 0x10)) = al; 0x00406ab9 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406abe je 0x406af0 | 0x00406ac0 cmp byte [rsp + 0x10], 0xff | | if (*((rsp + 0x10)) == 0xff) { 0x00406ac5 je 0x406af0 | goto label_68; | } 0x00406ac7 mov edi, 0x44f44e | 0x00406acc mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x00406ad1 mov esi, 0x2c0 | esi = 0x2c0; 0x00406ad6 xor eax, eax | eax = 0; 0x00406ad8 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406add mov eax, dword [rip + 0x261ea5] | eax = (anonymous namespace)::testStatus; 0x00406ae3 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406ae6 ja 0x406af0 | goto label_68; | } 0x00406ae8 inc eax | eax++; 0x00406aea mov dword [rip + 0x261e98], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_68: 0x00406af0 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) == 0) { 0x00406af5 je 0x40733d | goto label_69; | } 0x00406afb xor ecx, ecx | ecx = 0; 0x00406afd jmp 0x407376 | | } else { 0x00406b02 cmp byte [r14], 0 | 0x00406b06 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406b09 and r12b, cl | r12b &= cl; 0x00406b0c cmp r12b, 1 | | if (r12b == 1) { 0x00406b10 jne 0x406b3d | 0x00406b12 mov edi, 0x44f44e | 0x00406b17 mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x00406b1c mov esi, 0x256 | esi = 0x256; 0x00406b21 xor eax, eax | eax = 0; 0x00406b23 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b28 mov eax, dword [rip + 0x261e5a] | eax = (anonymous namespace)::testStatus; 0x00406b2e mov cl, 1 | cl = 1; 0x00406b30 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406b33 ja 0x406b3d | goto label_52; | } 0x00406b35 inc eax | eax++; 0x00406b37 mov dword [rip + 0x261e4b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_52: 0x00406b3d mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x00406b41 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406b46 je 0x406b78 | 0x00406b48 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) == 0) { 0x00406b4d je 0x406b78 | goto label_70; | } 0x00406b4f mov edi, 0x44f44e | 0x00406b54 mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x00406b59 mov esi, 0x258 | esi = 0x258; 0x00406b5e xor eax, eax | eax = 0; 0x00406b60 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b65 mov eax, dword [rip + 0x261e1d] | eax = (anonymous namespace)::testStatus; 0x00406b6b cmp eax, 0x64 | | if (eax > 0x64) { 0x00406b6e ja 0x406b78 | goto label_70; | } 0x00406b70 inc eax | eax++; 0x00406b72 mov dword [rip + 0x261e10], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_70: 0x00406b78 mov r13d, dword [rsp + 0x2c] | r13d = *((rsp + 0x2c)); 0x00406b7d cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406b82 je 0x406bb2 | 0x00406b84 test r13d, r13d | | if (r13d == 0) { 0x00406b87 je 0x406bb2 | goto label_71; | } 0x00406b89 mov edi, 0x44f44e | 0x00406b8e mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x00406b93 mov esi, 0x259 | esi = 0x259; 0x00406b98 xor eax, eax | eax = 0; 0x00406b9a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406b9f mov eax, dword [rip + 0x261de3] | eax = (anonymous namespace)::testStatus; 0x00406ba5 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406ba8 ja 0x406bb2 | goto label_71; | } 0x00406baa inc eax | eax++; 0x00406bac mov dword [rip + 0x261dd6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_71: 0x00406bb2 mov bl, byte [rsp + 0x18] | bl = *((rsp + 0x18)); 0x00406bb6 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406bbb je 0x406beb | 0x00406bbd cmp bl, 0xff | | if (bl == 0xff) { 0x00406bc0 je 0x406beb | goto label_72; | } 0x00406bc2 mov edi, 0x44f44e | 0x00406bc7 mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x00406bcc mov esi, 0x25b | esi = 0x25b; 0x00406bd1 xor eax, eax | eax = 0; 0x00406bd3 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406bd8 mov eax, dword [rip + 0x261daa] | eax = (anonymous namespace)::testStatus; 0x00406bde cmp eax, 0x64 | | if (eax > 0x64) { 0x00406be1 ja 0x406beb | goto label_72; | } 0x00406be3 inc eax | eax++; 0x00406be5 mov dword [rip + 0x261d9d], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_72: 0x00406beb mov r12b, byte [rsp + 0x19] | r12b = *((rsp + 0x19)); 0x00406bf0 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406bf5 je 0x406c26 | 0x00406bf7 cmp r12b, 0xff | | if (r12b == 0xff) { 0x00406bfb je 0x406c26 | goto label_73; | } 0x00406bfd mov edi, 0x44f44e | 0x00406c02 mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x00406c07 mov esi, 0x25c | esi = 0x25c; 0x00406c0c xor eax, eax | eax = 0; 0x00406c0e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c13 mov eax, dword [rip + 0x261d6f] | eax = (anonymous namespace)::testStatus; 0x00406c19 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c1c ja 0x406c26 | goto label_73; | } 0x00406c1e inc eax | eax++; 0x00406c20 mov dword [rip + 0x261d62], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_73: 0x00406c26 mov byte [rsp + 0xf], bl | *((rsp + 0xf)) = bl; 0x00406c2a mov r14b, byte [rsp + 0x1a] | r14b = *((rsp + 0x1a)); 0x00406c2f cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406c34 je 0x406c65 | 0x00406c36 cmp r14b, 0xff | | if (r14b == 0xff) { 0x00406c3a je 0x406c65 | goto label_74; | } 0x00406c3c mov edi, 0x44f44e | 0x00406c41 mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x00406c46 mov esi, 0x25d | esi = 0x25d; 0x00406c4b xor eax, eax | eax = 0; 0x00406c4d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c52 mov eax, dword [rip + 0x261d30] | eax = (anonymous namespace)::testStatus; 0x00406c58 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c5b ja 0x406c65 | goto label_74; | } 0x00406c5d inc eax | eax++; 0x00406c5f mov dword [rip + 0x261d23], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_74: 0x00406c65 mov bl, byte [rsp + 0x1b] | bl = *((rsp + 0x1b)); 0x00406c69 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406c6e je 0x406c9e | 0x00406c70 cmp bl, 0xff | | if (bl == 0xff) { 0x00406c73 je 0x406c9e | goto label_75; | } 0x00406c75 mov edi, 0x44f44e | 0x00406c7a mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x00406c7f mov esi, 0x25e | esi = 0x25e; 0x00406c84 xor eax, eax | eax = 0; 0x00406c86 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406c8b mov eax, dword [rip + 0x261cf7] | eax = (anonymous namespace)::testStatus; 0x00406c91 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406c94 ja 0x406c9e | goto label_75; | } 0x00406c96 inc eax | eax++; 0x00406c98 mov dword [rip + 0x261cea], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_75: 0x00406c9e cmp byte [rsp + 0x38], 0xff | 0x00406ca3 sete sil | sil = (*((rsp + 0x38)) == 0xff) ? 1 : 0; 0x00406ca7 cmp byte [rsp + 0xe], 0xff | 0x00406cac sete cl | cl = (*((rsp + 0xe)) == 0xff) ? 1 : 0; 0x00406caf cmp byte [rsp + 0x3c], 0xff | 0x00406cb4 sete dl | dl = (*((rsp + 0x3c)) == 0xff) ? 1 : 0; 0x00406cb7 cmp byte [rsp + 0x28], 0xff | 0x00406cbc sete al | al = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x00406cbf mov edi, dword [rsp + 0x24] | edi = *((rsp + 0x24)); 0x00406cc3 or dil, al | dil |= al; 0x00406cc6 mov eax, dword [rsp + 0x30] | eax = *((rsp + 0x30)); 0x00406cca xor al, 1 | al ^= 1; 0x00406ccc or al, dl | al |= dl; 0x00406cce or al, dil | al |= dil; 0x00406cd1 xor bpl, 1 | bpl ^= 1; 0x00406cd5 or bpl, cl | bpl |= cl; 0x00406cd8 or bpl, sil | bpl |= sil; 0x00406cdb or bpl, al | bpl |= al; 0x00406cde or bpl, byte [rsp + 0x34] | bpl |= *((rsp + 0x34)); 0x00406ce3 and bl, r14b | bl &= r14b; 0x00406ce6 cmp bl, 0xff | 0x00406ce9 sete al | al = (bl == 0xff) ? 1 : 0; 0x00406cec not bpl | bpl = ~bpl; 0x00406cef or r13d, dword [rsp + 0x10] | r13d |= *((rsp + 0x10)); 0x00406cf4 sete cl | cl = (r13d == 0) ? 1 : 0; 0x00406cf7 and r12b, byte [rsp + 0xf] | r12b &= *((rsp + 0xf)); 0x00406cfc cmp r12b, 0xff | 0x00406d00 jmp 0x407544 | goto label_76; | } 0x00406d05 cmp byte [r14], 0 | 0x00406d09 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406d0c and r13b, cl | r13b &= cl; 0x00406d0f cmp r13b, 1 | | if (r13b == 1) { 0x00406d13 jne 0x406d40 | 0x00406d15 mov edi, 0x44f44e | 0x00406d1a mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x00406d1f mov esi, 0x271 | esi = 0x271; 0x00406d24 xor eax, eax | eax = 0; 0x00406d26 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406d2b mov eax, dword [rip + 0x261c57] | eax = (anonymous namespace)::testStatus; 0x00406d31 mov cl, 1 | cl = 1; 0x00406d33 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406d36 ja 0x406d40 | goto label_56; | } 0x00406d38 inc eax | eax++; 0x00406d3a mov dword [rip + 0x261c48], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_56: 0x00406d40 mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x00406d44 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406d49 je 0x406d78 | 0x00406d4b test ebp, ebp | | if (ebp == 0) { 0x00406d4d je 0x406d78 | goto label_77; | } 0x00406d4f mov edi, 0x44f44e | 0x00406d54 mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x00406d59 mov esi, 0x273 | esi = 0x273; 0x00406d5e xor eax, eax | eax = 0; 0x00406d60 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406d65 mov eax, dword [rip + 0x261c1d] | eax = (anonymous namespace)::testStatus; 0x00406d6b cmp eax, 0x64 | | if (eax > 0x64) { 0x00406d6e ja 0x406d78 | goto label_77; | } 0x00406d70 inc eax | eax++; 0x00406d72 mov dword [rip + 0x261c10], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_77: 0x00406d78 mov byte [rsp + 0xe], bl | *((rsp + 0xe)) = bl; 0x00406d7c mov ebx, dword [rsp + 0x2c] | ebx = *((rsp + 0x2c)); 0x00406d80 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406d85 je 0x406db5 | 0x00406d87 cmp ebx, 3 | | if (ebx == 3) { 0x00406d8a je 0x406db5 | goto label_78; | } 0x00406d8c mov edi, 0x44f44e | 0x00406d91 mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x00406d96 mov esi, 0x274 | esi = 0x274; 0x00406d9b xor eax, eax | eax = 0; 0x00406d9d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406da2 mov eax, dword [rip + 0x261be0] | eax = (anonymous namespace)::testStatus; 0x00406da8 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406dab ja 0x406db5 | goto label_78; | } 0x00406dad inc eax | eax++; 0x00406daf mov dword [rip + 0x261bd3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_78: 0x00406db5 mov r15b, byte [rsp + 0x18] | r15b = *((rsp + 0x18)); 0x00406dba cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406dbf je 0x406df0 | 0x00406dc1 cmp r15b, 0x3d | | if (r15b != 0x3d) { 0x00406dc5 jne 0x406df0 | goto label_79; | } 0x00406dc7 mov edi, 0x44f44e | 0x00406dcc mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x00406dd1 mov esi, 0x276 | esi = 0x276; 0x00406dd6 xor eax, eax | eax = 0; 0x00406dd8 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406ddd mov eax, dword [rip + 0x261ba5] | eax = (anonymous namespace)::testStatus; 0x00406de3 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406de6 ja 0x406df0 | goto label_79; | } 0x00406de8 inc eax | eax++; 0x00406dea mov dword [rip + 0x261b98], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_79: 0x00406df0 mov dword [rsp + 0x30], ebx | *((rsp + 0x30)) = ebx; 0x00406df4 mov r14b, byte [rsp + 0x19] | r14b = *((rsp + 0x19)); 0x00406df9 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406dfe je 0x406e2f | 0x00406e00 cmp r14b, 0x3d | | if (r14b == 0x3d) { 0x00406e04 je 0x406e2f | goto label_80; | } 0x00406e06 mov edi, 0x44f44e | 0x00406e0b mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x00406e10 mov esi, 0x277 | esi = 0x277; 0x00406e15 xor eax, eax | eax = 0; 0x00406e17 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e1c mov eax, dword [rip + 0x261b66] | eax = (anonymous namespace)::testStatus; 0x00406e22 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e25 ja 0x406e2f | goto label_80; | } 0x00406e27 inc eax | eax++; 0x00406e29 mov dword [rip + 0x261b59], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_80: 0x00406e2f mov ebx, ebp | ebx = ebp; 0x00406e31 mov r13b, byte [rsp + 0x1a] | r13b = *((rsp + 0x1a)); 0x00406e36 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406e3b je 0x406e6c | 0x00406e3d cmp r13b, 0x3d | | if (r13b == 0x3d) { 0x00406e41 je 0x406e6c | goto label_81; | } 0x00406e43 mov edi, 0x44f44e | 0x00406e48 mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x00406e4d mov esi, 0x278 | esi = 0x278; 0x00406e52 xor eax, eax | eax = 0; 0x00406e54 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e59 mov eax, dword [rip + 0x261b29] | eax = (anonymous namespace)::testStatus; 0x00406e5f cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e62 ja 0x406e6c | goto label_81; | } 0x00406e64 inc eax | eax++; 0x00406e66 mov dword [rip + 0x261b1c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_81: 0x00406e6c mov bpl, byte [rsp + 0x1b] | bpl = *((rsp + 0x1b)); 0x00406e71 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406e76 je 0x406ea7 | 0x00406e78 cmp bpl, 0xff | | if (bpl == 0xff) { 0x00406e7c je 0x406ea7 | goto label_82; | } 0x00406e7e mov edi, 0x44f44e | 0x00406e83 mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x00406e88 mov esi, 0x279 | esi = 0x279; 0x00406e8d xor eax, eax | eax = 0; 0x00406e8f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406e94 mov eax, dword [rip + 0x261aee] | eax = (anonymous namespace)::testStatus; 0x00406e9a cmp eax, 0x64 | | if (eax > 0x64) { 0x00406e9d ja 0x406ea7 | goto label_82; | } 0x00406e9f inc eax | eax++; 0x00406ea1 mov dword [rip + 0x261ae1], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_82: 0x00406ea7 not bpl | bpl = ~bpl; 0x00406eaa xor r13b, 0x3d | r13b ^= 0x3d; 0x00406eae cmp r14b, 0x3d | 0x00406eb2 sete r10b | r10b = (r14b == 0x3d) ? 1 : 0; 0x00406eb6 cmp r15b, 0x3d | 0x00406eba setne dil | dil = (r15b != 0x3d) ? 1 : 0; 0x00406ebe cmp dword [rsp + 0x30], 3 | 0x00406ec3 sete r8b | r8b = (*((rsp + 0x30)) == 3) ? 1 : 0; 0x00406ec7 test ebx, ebx | 0x00406ec9 sete bl | bl = (ebx == 0) ? 1 : 0; 0x00406ecc cmp byte [rsp + 0x38], 0xff | 0x00406ed1 sete r9b | r9b = (*((rsp + 0x38)) == 0xff) ? 1 : 0; 0x00406ed5 cmp byte [rsp + 0xe], 0xff | 0x00406eda sete cl | cl = (*((rsp + 0xe)) == 0xff) ? 1 : 0; 0x00406edd cmp byte [rsp + 0x24], 0xff | 0x00406ee2 sete dl | dl = (*((rsp + 0x24)) == 0xff) ? 1 : 0; 0x00406ee5 cmp byte [rsp + 0x10], 0xff | 0x00406eea sete al | al = (*((rsp + 0x10)) == 0xff) ? 1 : 0; 0x00406eed mov esi, dword [rsp + 0x28] | esi = *((rsp + 0x28)); 0x00406ef1 or sil, al | sil |= al; 0x00406ef4 or sil, dl | sil |= dl; 0x00406ef7 or sil, byte [rsp + 0x3c] | sil |= *((rsp + 0x3c)); 0x00406efc xor r12b, 1 | r12b ^= 1; 0x00406f00 or r12b, cl | r12b |= cl; 0x00406f03 or r12b, r9b | r12b |= r9b; 0x00406f06 or r12b, sil | r12b |= sil; 0x00406f09 or r12b, byte [rsp + 0x34] | r12b |= *((rsp + 0x34)); 0x00406f0e or r13b, bpl | r13b |= bpl; 0x00406f11 jmp 0x40711f | goto label_83; | label_60: 0x00406f16 cmp byte [r14], 0 | 0x00406f1a sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00406f1d and r13b, cl | r13b &= cl; 0x00406f20 cmp r13b, 1 | | if (r13b == 1) { 0x00406f24 jne 0x406f51 | 0x00406f26 mov edi, 0x44f44e | 0x00406f2b mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x00406f30 mov esi, 0x28c | esi = 0x28c; 0x00406f35 xor eax, eax | eax = 0; 0x00406f37 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406f3c mov eax, dword [rip + 0x261a46] | eax = (anonymous namespace)::testStatus; 0x00406f42 mov cl, 1 | cl = 1; 0x00406f44 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406f47 ja 0x406f51 | goto label_61; | } 0x00406f49 inc eax | eax++; 0x00406f4b mov dword [rip + 0x261a37], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_61: 0x00406f51 mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x00406f55 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406f5a je 0x406f89 | 0x00406f5c test ebp, ebp | | if (ebp == 0) { 0x00406f5e je 0x406f89 | goto label_84; | } 0x00406f60 mov edi, 0x44f44e | 0x00406f65 mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x00406f6a mov esi, 0x28e | esi = 0x28e; 0x00406f6f xor eax, eax | eax = 0; 0x00406f71 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406f76 mov eax, dword [rip + 0x261a0c] | eax = (anonymous namespace)::testStatus; 0x00406f7c cmp eax, 0x64 | | if (eax > 0x64) { 0x00406f7f ja 0x406f89 | goto label_84; | } 0x00406f81 inc eax | eax++; 0x00406f83 mov dword [rip + 0x2619ff], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_84: 0x00406f89 mov byte [rsp + 0xe], bl | *((rsp + 0xe)) = bl; 0x00406f8d mov ebx, dword [rsp + 0x2c] | ebx = *((rsp + 0x2c)); 0x00406f91 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406f96 je 0x406fc6 | 0x00406f98 cmp ebx, 2 | | if (ebx == 2) { 0x00406f9b je 0x406fc6 | goto label_85; | } 0x00406f9d mov edi, 0x44f44e | 0x00406fa2 mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x00406fa7 mov esi, 0x28f | esi = 0x28f; 0x00406fac xor eax, eax | eax = 0; 0x00406fae call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406fb3 mov eax, dword [rip + 0x2619cf] | eax = (anonymous namespace)::testStatus; 0x00406fb9 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406fbc ja 0x406fc6 | goto label_85; | } 0x00406fbe inc eax | eax++; 0x00406fc0 mov dword [rip + 0x2619c2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_85: 0x00406fc6 mov r15b, byte [rsp + 0x18] | r15b = *((rsp + 0x18)); 0x00406fcb cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00406fd0 je 0x407001 | 0x00406fd2 cmp r15b, 0x3d | | if (r15b != 0x3d) { 0x00406fd6 jne 0x407001 | goto label_86; | } 0x00406fd8 mov edi, 0x44f44e | 0x00406fdd mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x00406fe2 mov esi, 0x291 | esi = 0x291; 0x00406fe7 xor eax, eax | eax = 0; 0x00406fe9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00406fee mov eax, dword [rip + 0x261994] | eax = (anonymous namespace)::testStatus; 0x00406ff4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00406ff7 ja 0x407001 | goto label_86; | } 0x00406ff9 inc eax | eax++; 0x00406ffb mov dword [rip + 0x261987], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_86: 0x00407001 mov dword [rsp + 0x30], ebx | *((rsp + 0x30)) = ebx; 0x00407005 mov r14b, byte [rsp + 0x19] | r14b = *((rsp + 0x19)); 0x0040700a cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040700f je 0x407040 | 0x00407011 cmp r14b, 0x3d | | if (r14b == 0x3d) { 0x00407015 je 0x407040 | goto label_87; | } 0x00407017 mov edi, 0x44f44e | 0x0040701c mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x00407021 mov esi, 0x292 | esi = 0x292; 0x00407026 xor eax, eax | eax = 0; 0x00407028 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040702d mov eax, dword [rip + 0x261955] | eax = (anonymous namespace)::testStatus; 0x00407033 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407036 ja 0x407040 | goto label_87; | } 0x00407038 inc eax | eax++; 0x0040703a mov dword [rip + 0x261948], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_87: 0x00407040 mov ebx, ebp | ebx = ebp; 0x00407042 mov r13b, byte [rsp + 0x1a] | r13b = *((rsp + 0x1a)); 0x00407047 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040704c je 0x40707d | 0x0040704e cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407052 je 0x40707d | goto label_88; | } 0x00407054 mov edi, 0x44f44e | 0x00407059 mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x0040705e mov esi, 0x293 | esi = 0x293; 0x00407063 xor eax, eax | eax = 0; 0x00407065 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040706a mov eax, dword [rip + 0x261918] | eax = (anonymous namespace)::testStatus; 0x00407070 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407073 ja 0x40707d | goto label_88; | } 0x00407075 inc eax | eax++; 0x00407077 mov dword [rip + 0x26190b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_88: 0x0040707d mov bpl, byte [rsp + 0x1b] | bpl = *((rsp + 0x1b)); 0x00407082 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407087 je 0x4070b8 | 0x00407089 cmp bpl, 0xff | | if (bpl == 0xff) { 0x0040708d je 0x4070b8 | goto label_89; | } 0x0040708f mov edi, 0x44f44e | 0x00407094 mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x00407099 mov esi, 0x294 | esi = 0x294; 0x0040709e xor eax, eax | eax = 0; 0x004070a0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004070a5 mov eax, dword [rip + 0x2618dd] | eax = (anonymous namespace)::testStatus; 0x004070ab cmp eax, 0x64 | | if (eax > 0x64) { 0x004070ae ja 0x4070b8 | goto label_89; | } 0x004070b0 inc eax | eax++; 0x004070b2 mov dword [rip + 0x2618d0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_89: 0x004070b8 cmp r14b, 0x3d | 0x004070bc sete r10b | r10b = (r14b == 0x3d) ? 1 : 0; 0x004070c0 cmp r15b, 0x3d | 0x004070c4 setne dil | dil = (r15b != 0x3d) ? 1 : 0; 0x004070c8 cmp dword [rsp + 0x30], 2 | 0x004070cd sete r8b | r8b = (*((rsp + 0x30)) == 2) ? 1 : 0; 0x004070d1 test ebx, ebx | 0x004070d3 sete bl | bl = (ebx == 0) ? 1 : 0; 0x004070d6 cmp byte [rsp + 0x38], 0xff | 0x004070db sete r9b | r9b = (*((rsp + 0x38)) == 0xff) ? 1 : 0; 0x004070df cmp byte [rsp + 0xe], 0xff | 0x004070e4 sete cl | cl = (*((rsp + 0xe)) == 0xff) ? 1 : 0; 0x004070e7 cmp byte [rsp + 0x24], 0xff | 0x004070ec sete dl | dl = (*((rsp + 0x24)) == 0xff) ? 1 : 0; 0x004070ef cmp byte [rsp + 0x10], 0xff | 0x004070f4 sete al | al = (*((rsp + 0x10)) == 0xff) ? 1 : 0; 0x004070f7 mov esi, dword [rsp + 0x28] | esi = *((rsp + 0x28)); 0x004070fb or sil, al | sil |= al; 0x004070fe or sil, dl | sil |= dl; 0x00407101 or sil, byte [rsp + 0x3c] | sil |= *((rsp + 0x3c)); 0x00407106 xor r12b, 1 | r12b ^= 1; 0x0040710a or r12b, cl | r12b |= cl; 0x0040710d or r12b, r9b | r12b |= r9b; 0x00407110 or r12b, sil | r12b |= sil; 0x00407113 or r12b, byte [rsp + 0x34] | r12b |= *((rsp + 0x34)); 0x00407118 and bpl, r13b | bpl &= r13b; 0x0040711b cmp bpl, 0xff | | label_83: 0x0040711f sete al | al = (bpl == 0xff) ? 1 : 0; 0x00407122 not r12b | r12b = ~r12b; 0x00407125 and bl, r8b | bl &= r8b; 0x00407128 and bl, dil | bl &= dil; 0x0040712b and bl, r10b | bl &= r10b; 0x0040712e and bl, al | bl &= al; 0x00407130 and bl, r12b | bl &= r12b; 0x00407133 jmp 0x407860 | goto label_23; | label_65: 0x00407138 cmp byte [r14], 0 | 0x0040713c sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x0040713f and r12b, cl | r12b &= cl; 0x00407142 cmp r12b, 1 | | if (r12b == 1) { 0x00407146 jne 0x407173 | 0x00407148 mov edi, 0x44f44e | 0x0040714d mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x00407152 mov esi, 0x2a7 | esi = 0x2a7; 0x00407157 xor eax, eax | eax = 0; 0x00407159 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040715e mov eax, dword [rip + 0x261824] | eax = (anonymous namespace)::testStatus; 0x00407164 mov cl, 1 | cl = 1; 0x00407166 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407169 ja 0x407173 | goto label_66; | } 0x0040716b inc eax | eax++; 0x0040716d mov dword [rip + 0x261815], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_66: 0x00407173 mov dword [rsp + 0x34], ecx | *((rsp + 0x34)) = ecx; 0x00407177 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040717c je 0x4071ae | 0x0040717e cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) == 0) { 0x00407183 je 0x4071ae | goto label_90; | } 0x00407185 mov edi, 0x44f44e | 0x0040718a mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x0040718f mov esi, 0x2a9 | esi = 0x2a9; 0x00407194 xor eax, eax | eax = 0; 0x00407196 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040719b mov eax, dword [rip + 0x2617e7] | eax = (anonymous namespace)::testStatus; 0x004071a1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004071a4 ja 0x4071ae | goto label_90; | } 0x004071a6 inc eax | eax++; 0x004071a8 mov dword [rip + 0x2617da], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_90: 0x004071ae mov ebx, dword [rsp + 0x2c] | ebx = *((rsp + 0x2c)); 0x004071b2 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004071b7 je 0x4071e6 | 0x004071b9 test ebx, ebx | | if (ebx == 0) { 0x004071bb je 0x4071e6 | goto label_91; | } 0x004071bd mov edi, 0x44f44e | 0x004071c2 mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x004071c7 mov esi, 0x2aa | esi = 0x2aa; 0x004071cc xor eax, eax | eax = 0; 0x004071ce call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004071d3 mov eax, dword [rip + 0x2617af] | eax = (anonymous namespace)::testStatus; 0x004071d9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004071dc ja 0x4071e6 | goto label_91; | } 0x004071de inc eax | eax++; 0x004071e0 mov dword [rip + 0x2617a2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_91: 0x004071e6 mov dword [rsp + 0x30], ebx | *((rsp + 0x30)) = ebx; 0x004071ea mov bl, byte [rsp + 0x18] | bl = *((rsp + 0x18)); 0x004071ee cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004071f3 je 0x407223 | 0x004071f5 cmp bl, 0xff | | if (bl == 0xff) { 0x004071f8 je 0x407223 | goto label_92; | } 0x004071fa mov edi, 0x44f44e | 0x004071ff mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x00407204 mov esi, 0x2ac | esi = 0x2ac; 0x00407209 xor eax, eax | eax = 0; 0x0040720b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407210 mov eax, dword [rip + 0x261772] | eax = (anonymous namespace)::testStatus; 0x00407216 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407219 ja 0x407223 | goto label_92; | } 0x0040721b inc eax | eax++; 0x0040721d mov dword [rip + 0x261765], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_92: 0x00407223 mov r14b, byte [rsp + 0x19] | r14b = *((rsp + 0x19)); 0x00407228 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040722d je 0x40725e | 0x0040722f cmp r14b, 0xff | | if (r14b == 0xff) { 0x00407233 je 0x40725e | goto label_93; | } 0x00407235 mov edi, 0x44f44e | 0x0040723a mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x0040723f mov esi, 0x2ad | esi = 0x2ad; 0x00407244 xor eax, eax | eax = 0; 0x00407246 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040724b mov eax, dword [rip + 0x261737] | eax = (anonymous namespace)::testStatus; 0x00407251 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407254 ja 0x40725e | goto label_93; | } 0x00407256 inc eax | eax++; 0x00407258 mov dword [rip + 0x26172a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_93: 0x0040725e mov r13b, byte [rsp + 0x1a] | r13b = *((rsp + 0x1a)); 0x00407263 mov al, byte [rsp + 0xd] | al = *((rsp + 0xd)); 0x00407267 mov r15d, eax | r15d = eax; 0x0040726a test al, al | | if (al != 0) { 0x0040726c je 0x40729d | 0x0040726e cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407272 je 0x40729d | goto label_94; | } 0x00407274 mov edi, 0x44f44e | 0x00407279 mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x0040727e mov esi, 0x2ae | esi = 0x2ae; 0x00407283 xor eax, eax | eax = 0; 0x00407285 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040728a mov eax, dword [rip + 0x2616f8] | eax = (anonymous namespace)::testStatus; 0x00407290 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407293 ja 0x40729d | goto label_94; | } 0x00407295 inc eax | eax++; 0x00407297 mov dword [rip + 0x2616eb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_94: 0x0040729d mov byte [rsp + 0x43], bl | *((rsp + 0x43)) = bl; 0x004072a1 mov r12b, byte [rsp + 0x1b] | r12b = *((rsp + 0x1b)); 0x004072a6 test r15b, r15b | | if (r15b != 0) { 0x004072a9 je 0x4072da | 0x004072ab cmp r12b, 0xff | | if (r12b == 0xff) { 0x004072af je 0x4072da | goto label_95; | } 0x004072b1 mov edi, 0x44f44e | 0x004072b6 mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x004072bb mov esi, 0x2af | esi = 0x2af; 0x004072c0 xor eax, eax | eax = 0; 0x004072c2 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004072c7 mov eax, dword [rip + 0x2616bb] | eax = (anonymous namespace)::testStatus; 0x004072cd cmp eax, 0x64 | | if (eax > 0x64) { 0x004072d0 ja 0x4072da | goto label_95; | } 0x004072d2 inc eax | eax++; 0x004072d4 mov dword [rip + 0x2616ae], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_95: 0x004072da cmp byte [rsp + 0xf], 0xff | 0x004072df sete al | al = (*((rsp + 0xf)) == 0xff) ? 1 : 0; 0x004072e2 cmp byte [rsp + 0x38], 0xff | 0x004072e7 sete cl | cl = (*((rsp + 0x38)) == 0xff) ? 1 : 0; 0x004072ea cmp byte [rsp + 0x24], 0xff | 0x004072ef sete dl | dl = (*((rsp + 0x24)) == 0xff) ? 1 : 0; 0x004072f2 cmp byte [rsp + 0xe], 0xff | 0x004072f7 sete bl | bl = (*((rsp + 0xe)) == 0xff) ? 1 : 0; 0x004072fa mov esi, dword [rsp + 0x28] | esi = *((rsp + 0x28)); 0x004072fe or sil, bl | sil |= bl; 0x00407301 or sil, dl | sil |= dl; 0x00407304 or sil, byte [rsp + 0x3c] | sil |= *((rsp + 0x3c)); 0x00407309 xor bpl, 1 | bpl ^= 1; 0x0040730d or bpl, cl | bpl |= cl; 0x00407310 or bpl, al | bpl |= al; 0x00407313 or bpl, sil | bpl |= sil; 0x00407316 or bpl, byte [rsp + 0x34] | bpl |= *((rsp + 0x34)); 0x0040731b and r12b, r13b | r12b &= r13b; 0x0040731e cmp r12b, 0xff | 0x00407322 sete al | al = (r12b == 0xff) ? 1 : 0; 0x00407325 not bpl | bpl = ~bpl; 0x00407328 mov ecx, dword [rsp + 0x30] | ecx = *((rsp + 0x30)); 0x0040732c or ecx, dword [rsp + 0x10] | ecx |= *((rsp + 0x10)); 0x00407330 sete cl | cl = (ecx == 0) ? 1 : 0; 0x00407333 and r14b, byte [rsp + 0x43] | r14b &= *((rsp + 0x43)); 0x00407338 jmp 0x407540 | goto label_96; | label_69: 0x0040733d cmp byte [r14], 0 | 0x00407341 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00407344 and bl, cl | bl &= cl; 0x00407346 cmp bl, 1 | | if (bl != 1) { 0x00407349 jne 0x407376 | goto label_97; | } 0x0040734b mov edi, 0x44f44e | 0x00407350 mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x00407355 mov esi, 0x2c1 | esi = 0x2c1; 0x0040735a xor eax, eax | eax = 0; 0x0040735c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407361 mov eax, dword [rip + 0x261621] | eax = (anonymous namespace)::testStatus; 0x00407367 mov cl, 1 | cl = 1; 0x00407369 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040736c ja 0x407376 | goto label_97; | } 0x0040736e inc eax | eax++; 0x00407370 mov dword [rip + 0x261612], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_97: 0x00407376 mov dword [rsp + 0x30], ecx | *((rsp + 0x30)) = ecx; 0x0040737a cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040737f je 0x4073b0 | 0x00407381 cmp r12d, 0xffffffff | | if (r12d == 0xffffffff) { 0x00407385 je 0x4073b0 | goto label_98; | } 0x00407387 mov edi, 0x44f44e | 0x0040738c mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x00407391 mov esi, 0x2c3 | esi = 0x2c3; 0x00407396 xor eax, eax | eax = 0; 0x00407398 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040739d mov eax, dword [rip + 0x2615e5] | eax = (anonymous namespace)::testStatus; 0x004073a3 cmp eax, 0x64 | | if (eax > 0x64) { 0x004073a6 ja 0x4073b0 | goto label_98; | } 0x004073a8 inc eax | eax++; 0x004073aa mov dword [rip + 0x2615d8], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_98: 0x004073b0 mov dword [rsp + 0x38], r12d | *((rsp + 0x38)) = r12d; 0x004073b5 mov r15d, dword [rsp + 0x2c] | r15d = *((rsp + 0x2c)); 0x004073ba cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004073bf je 0x4073ef | 0x004073c1 test r15d, r15d | | if (r15d == 0) { 0x004073c4 je 0x4073ef | goto label_99; | } 0x004073c6 mov edi, 0x44f44e | 0x004073cb mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x004073d0 mov esi, 0x2c4 | esi = 0x2c4; 0x004073d5 xor eax, eax | eax = 0; 0x004073d7 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004073dc mov eax, dword [rip + 0x2615a6] | eax = (anonymous namespace)::testStatus; 0x004073e2 cmp eax, 0x64 | | if (eax > 0x64) { 0x004073e5 ja 0x4073ef | goto label_99; | } 0x004073e7 inc eax | eax++; 0x004073e9 mov dword [rip + 0x261599], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_99: 0x004073ef mov r12b, byte [rsp + 0x18] | r12b = *((rsp + 0x18)); 0x004073f4 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004073f9 je 0x40742a | 0x004073fb cmp r12b, 0xff | | if (r12b == 0xff) { 0x004073ff je 0x40742a | goto label_100; | } 0x00407401 mov edi, 0x44f44e | 0x00407406 mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x0040740b mov esi, 0x2c6 | esi = 0x2c6; 0x00407410 xor eax, eax | eax = 0; 0x00407412 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407417 mov eax, dword [rip + 0x26156b] | eax = (anonymous namespace)::testStatus; 0x0040741d cmp eax, 0x64 | | if (eax > 0x64) { 0x00407420 ja 0x40742a | goto label_100; | } 0x00407422 inc eax | eax++; 0x00407424 mov dword [rip + 0x26155e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_100: 0x0040742a mov dword [rsp + 0x34], r13d | *((rsp + 0x34)) = r13d; 0x0040742f mov r14b, byte [rsp + 0x19] | r14b = *((rsp + 0x19)); 0x00407434 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407439 je 0x40746a | 0x0040743b cmp r14b, 0xff | | if (r14b == 0xff) { 0x0040743f je 0x40746a | goto label_101; | } 0x00407441 mov edi, 0x44f44e | 0x00407446 mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x0040744b mov esi, 0x2c7 | esi = 0x2c7; 0x00407450 xor eax, eax | eax = 0; 0x00407452 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407457 mov eax, dword [rip + 0x26152b] | eax = (anonymous namespace)::testStatus; 0x0040745d cmp eax, 0x64 | | if (eax > 0x64) { 0x00407460 ja 0x40746a | goto label_101; | } 0x00407462 inc eax | eax++; 0x00407464 mov dword [rip + 0x26151e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_101: 0x0040746a mov r13b, byte [rsp + 0x1a] | r13b = *((rsp + 0x1a)); 0x0040746f cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407474 je 0x4074a5 | 0x00407476 cmp r13b, 0xff | | if (r13b == 0xff) { 0x0040747a je 0x4074a5 | goto label_102; | } 0x0040747c mov edi, 0x44f44e | 0x00407481 mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x00407486 mov esi, 0x2c8 | esi = 0x2c8; 0x0040748b xor eax, eax | eax = 0; 0x0040748d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407492 mov eax, dword [rip + 0x2614f0] | eax = (anonymous namespace)::testStatus; 0x00407498 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040749b ja 0x4074a5 | goto label_102; | } 0x0040749d inc eax | eax++; 0x0040749f mov dword [rip + 0x2614e3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_102: 0x004074a5 mov bl, byte [rsp + 0x1b] | bl = *((rsp + 0x1b)); 0x004074a9 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004074ae je 0x4074de | 0x004074b0 cmp bl, 0xff | | if (bl == 0xff) { 0x004074b3 je 0x4074de | goto label_103; | } 0x004074b5 mov edi, 0x44f44e | 0x004074ba mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x004074bf mov esi, 0x2c9 | esi = 0x2c9; 0x004074c4 xor eax, eax | eax = 0; 0x004074c6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004074cb mov eax, dword [rip + 0x2614b7] | eax = (anonymous namespace)::testStatus; 0x004074d1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004074d4 ja 0x4074de | goto label_103; | } 0x004074d6 inc eax | eax++; 0x004074d8 mov dword [rip + 0x2614aa], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_103: 0x004074de test r15d, r15d | 0x004074e1 sete sil | sil = (r15d == 0) ? 1 : 0; 0x004074e5 cmp dword [rsp + 0x38], 0xffffffff | 0x004074ea sete cl | cl = (*((rsp + 0x38)) == 0xffffffff) ? 1 : 0; 0x004074ed cmp byte [rsp + 0x10], 0xff | 0x004074f2 setne dil | dil = (*((rsp + 0x10)) != 0xff) ? 1 : 0; 0x004074f6 cmp byte [rsp + 0xe], 0xff | 0x004074fb setne r8b | r8b = (*((rsp + 0xe)) != 0xff) ? 1 : 0; 0x004074ff cmp byte [rsp + 0x24], 0xff | 0x00407504 sete dl | dl = (*((rsp + 0x24)) == 0xff) ? 1 : 0; 0x00407507 cmp byte [rsp + 0x28], 0xff | 0x0040750c sete al | al = (*((rsp + 0x28)) == 0xff) ? 1 : 0; 0x0040750f xor bpl, 1 | bpl ^= 1; 0x00407513 or bpl, al | bpl |= al; 0x00407516 or bpl, dl | bpl |= dl; 0x00407519 or bpl, byte [rsp + 0x3c] | bpl |= *((rsp + 0x3c)); 0x0040751e or bpl, r8b | bpl |= r8b; 0x00407521 or bpl, byte [rsp + 0x34] | bpl |= *((rsp + 0x34)); 0x00407526 or bpl, dil | bpl |= dil; 0x00407529 or bpl, byte [rsp + 0x30] | bpl |= *((rsp + 0x30)); 0x0040752e and bl, r13b | bl &= r13b; 0x00407531 cmp bl, 0xff | 0x00407534 sete al | al = (bl == 0xff) ? 1 : 0; 0x00407537 not bpl | bpl = ~bpl; 0x0040753a and cl, sil | cl &= sil; 0x0040753d and r14b, r12b | r14b &= r12b; | label_96: 0x00407540 cmp r14b, 0xff | | label_76: 0x00407544 sete bl | bl = (r14b == 0xff) ? 1 : 0; 0x00407547 and bl, cl | bl &= cl; 0x00407549 and bl, al | bl &= al; 0x0040754b and bl, bpl | bl &= bpl; 0x0040754e jmp 0x407860 | goto label_23; | label_48: 0x00407553 cmp byte [r14], 0 | 0x00407557 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x0040755a mov eax, ecx | eax = ecx; 0x0040755c and al, r12b | al &= r12b; 0x0040755f cmp al, 1 | | if (al != 1) { 0x00407561 jne 0x40758e | goto label_104; | } 0x00407563 mov edi, 0x44f44e | 0x00407568 mov edx, 0x44d551 | edx = "a3 || !enabled"; 0x0040756d mov esi, 0x2d3 | esi = 0x2d3; 0x00407572 xor eax, eax | eax = 0; 0x00407574 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407579 mov eax, dword [rip + 0x261409] | eax = (anonymous namespace)::testStatus; 0x0040757f mov cl, 1 | cl = 1; 0x00407581 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407584 ja 0x40758e | goto label_104; | } 0x00407586 inc eax | eax++; 0x00407588 mov dword [rip + 0x2613fa], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_104: 0x0040758e mov dword [rsp + 0x38], ecx | *((rsp + 0x38)) = ecx; 0x00407592 lea rsi, [rsp + 0x18] | 0x00407597 lea rdx, [rsp + 0x2c] | 0x0040759c mov rdi, r14 | 0x0040759f mov ecx, 0xffffffff | 0x004075a4 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r14, rsp + 0x18, rsp + 0x2c, 0xffffffff); 0x004075a9 mov dword [rsp + 0x10], eax | *((rsp + 0x10)) = eax; 0x004075ad mov dl, byte [r14] | dl = *(r14); 0x004075b0 cmp dl, 0xff | 0x004075b3 sete al | al = (dl == 0xff) ? 1 : 0; 0x004075b6 mov ecx, r12d | ecx = r12d; 0x004075b9 xor cl, 1 | cl ^= 1; 0x004075bc or cl, al | cl |= al; 0x004075be mov byte [rsp + 0x34], dl | *((rsp + 0x34)) = dl; 0x004075c2 mov eax, edx | eax = edx; | if (cl == 0) { 0x004075c4 jne 0x4075f2 | 0x004075c6 mov edi, 0x44f44e | 0x004075cb mov edx, 0x44d560 | edx = "b0 || !enabled"; 0x004075d0 mov esi, 0x2d8 | esi = 0x2d8; 0x004075d5 xor eax, eax | eax = 0; 0x004075d7 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004075dc mov eax, dword [rip + 0x2613a6] | eax = (anonymous namespace)::testStatus; 0x004075e2 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004075e5 ja 0x4075ef | 0x004075e7 inc eax | eax++; 0x004075e9 mov dword [rip + 0x261399], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004075ef mov al, byte [r14] | al = *(r14); | } 0x004075f2 cmp al, 1 | | if (al == 1) { 0x004075f4 jne 0x407601 | 0x004075f6 cmp dword [r14 + 0x14], 0 | | if (*((r14 + 0x14)) == 0) { 0x004075fb je 0x407c18 | goto label_105; | } | } 0x00407601 mov dword [rsp + 0x24], 0 | *((rsp + 0x24)) = 0; | label_15: 0x00407609 mov al, byte [r14] | al = *(r14); 0x0040760c mov byte [rsp + 0x28], al | *((rsp + 0x28)) = al; 0x00407610 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407615 je 0x407647 | 0x00407617 cmp byte [rsp + 0x28], 0xff | | if (*((rsp + 0x28)) == 0xff) { 0x0040761c je 0x407647 | goto label_106; | } 0x0040761e mov edi, 0x44f44e | 0x00407623 mov edx, 0x44d57e | edx = "b2 || !enabled"; 0x00407628 mov esi, 0x2da | esi = 0x2da; 0x0040762d xor eax, eax | eax = 0; 0x0040762f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407634 mov eax, dword [rip + 0x26134e] | eax = (anonymous namespace)::testStatus; 0x0040763a cmp eax, 0x64 | | if (eax > 0x64) { 0x0040763d ja 0x407647 | goto label_106; | } 0x0040763f inc eax | eax++; 0x00407641 mov dword [rip + 0x261341], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_106: 0x00407647 cmp dword [r14 + 0xc], 0 | | if (*((r14 + 0xc)) != 0) { 0x0040764c je 0x407652 | 0x0040764e xor ecx, ecx | ecx = 0; 0x00407650 jmp 0x40768d | | } else { 0x00407652 cmp byte [r14], 0 | 0x00407656 sete cl | cl = (*(r14) == 0) ? 1 : 0; 0x00407659 and r12b, cl | r12b &= cl; 0x0040765c cmp r12b, 1 | | if (r12b != 1) { 0x00407660 jne 0x40768d | goto label_107; | } 0x00407662 mov edi, 0x44f44e | 0x00407667 mov edx, 0x44d58d | edx = "b3 || !enabled"; 0x0040766c mov esi, 0x2db | esi = 0x2db; 0x00407671 xor eax, eax | eax = 0; 0x00407673 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407678 mov eax, dword [rip + 0x26130a] | eax = (anonymous namespace)::testStatus; 0x0040767e mov cl, 1 | cl = 1; 0x00407680 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407683 ja 0x40768d | goto label_107; | } 0x00407685 inc eax | eax++; 0x00407687 mov dword [rip + 0x2612fb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_107: 0x0040768d mov dword [rsp + 0x30], ecx | *((rsp + 0x30)) = ecx; 0x00407691 mov dword [rsp + 0x3c], ebx | *((rsp + 0x3c)) = ebx; 0x00407695 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040769a je 0x4076cc | 0x0040769c cmp dword [rsp + 0x10], 0xffffffff | | if (*((rsp + 0x10)) == 0xffffffff) { 0x004076a1 je 0x4076cc | goto label_108; | } 0x004076a3 mov edi, 0x44f44e | 0x004076a8 mov edx, 0x44d59c | edx = "c0 || !enabled"; 0x004076ad mov esi, 0x2dd | esi = 0x2dd; 0x004076b2 xor eax, eax | eax = 0; 0x004076b4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004076b9 mov eax, dword [rip + 0x2612c9] | eax = (anonymous namespace)::testStatus; 0x004076bf cmp eax, 0x64 | | if (eax > 0x64) { 0x004076c2 ja 0x4076cc | goto label_108; | } 0x004076c4 inc eax | eax++; 0x004076c6 mov dword [rip + 0x2612bc], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_108: 0x004076cc mov r15d, dword [rsp + 0x2c] | r15d = *((rsp + 0x2c)); 0x004076d1 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004076d6 je 0x407706 | 0x004076d8 test r15d, r15d | | if (r15d == 0) { 0x004076db je 0x407706 | goto label_109; | } 0x004076dd mov edi, 0x44f44e | 0x004076e2 mov edx, 0x44d5ab | edx = "c1 || !enabled"; 0x004076e7 mov esi, 0x2de | esi = 0x2de; 0x004076ec xor eax, eax | eax = 0; 0x004076ee call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004076f3 mov eax, dword [rip + 0x26128f] | eax = (anonymous namespace)::testStatus; 0x004076f9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004076fc ja 0x407706 | goto label_109; | } 0x004076fe inc eax | eax++; 0x00407700 mov dword [rip + 0x261282], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_109: 0x00407706 mov bl, byte [rsp + 0x18] | bl = *((rsp + 0x18)); 0x0040770a cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040770f je 0x40773f | 0x00407711 cmp bl, 0xff | | if (bl == 0xff) { 0x00407714 je 0x40773f | goto label_110; | } 0x00407716 mov edi, 0x44f44e | 0x0040771b mov edx, 0x44d5ba | edx = "d0 || !enabled"; 0x00407720 mov esi, 0x2e0 | esi = 0x2e0; 0x00407725 xor eax, eax | eax = 0; 0x00407727 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040772c mov eax, dword [rip + 0x261256] | eax = (anonymous namespace)::testStatus; 0x00407732 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407735 ja 0x40773f | goto label_110; | } 0x00407737 inc eax | eax++; 0x00407739 mov dword [rip + 0x261249], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_110: 0x0040773f mov byte [rsp + 0xe], r13b | *((rsp + 0xe)) = r13b; 0x00407744 mov r12b, byte [rsp + 0x19] | r12b = *((rsp + 0x19)); 0x00407749 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040774e je 0x40777f | 0x00407750 cmp r12b, 0xff | | if (r12b == 0xff) { 0x00407754 je 0x40777f | goto label_111; | } 0x00407756 mov edi, 0x44f44e | 0x0040775b mov edx, 0x44d5c9 | edx = "d1 || !enabled"; 0x00407760 mov esi, 0x2e1 | esi = 0x2e1; 0x00407765 xor eax, eax | eax = 0; 0x00407767 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040776c mov eax, dword [rip + 0x261216] | eax = (anonymous namespace)::testStatus; 0x00407772 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407775 ja 0x40777f | goto label_111; | } 0x00407777 inc eax | eax++; 0x00407779 mov dword [rip + 0x261209], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_111: 0x0040777f mov byte [rsp + 0xf], bl | *((rsp + 0xf)) = bl; 0x00407783 mov r13b, byte [rsp + 0x1a] | r13b = *((rsp + 0x1a)); 0x00407788 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x0040778d je 0x4077be | 0x0040778f cmp r13b, 0xff | | if (r13b == 0xff) { 0x00407793 je 0x4077be | goto label_112; | } 0x00407795 mov edi, 0x44f44e | 0x0040779a mov edx, 0x44d5d8 | edx = "d2 || !enabled"; 0x0040779f mov esi, 0x2e2 | esi = 0x2e2; 0x004077a4 xor eax, eax | eax = 0; 0x004077a6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004077ab mov eax, dword [rip + 0x2611d7] | eax = (anonymous namespace)::testStatus; 0x004077b1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004077b4 ja 0x4077be | goto label_112; | } 0x004077b6 inc eax | eax++; 0x004077b8 mov dword [rip + 0x2611ca], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_112: 0x004077be mov r14b, byte [rsp + 0x1b] | r14b = *((rsp + 0x1b)); 0x004077c3 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x004077c8 je 0x4077f9 | 0x004077ca cmp r14b, 0xff | | if (r14b == 0xff) { 0x004077ce je 0x4077f9 | goto label_113; | } 0x004077d0 mov edi, 0x44f44e | 0x004077d5 mov edx, 0x44d5e7 | edx = "d3 || !enabled"; 0x004077da mov esi, 0x2e3 | esi = 0x2e3; 0x004077df xor eax, eax | eax = 0; 0x004077e1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004077e6 mov eax, dword [rip + 0x26119c] | eax = (anonymous namespace)::testStatus; 0x004077ec cmp eax, 0x64 | | if (eax > 0x64) { 0x004077ef ja 0x4077f9 | goto label_113; | } 0x004077f1 inc eax | eax++; 0x004077f3 mov dword [rip + 0x26118f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_113: 0x004077f9 test r15d, r15d | 0x004077fc sete sil | sil = (r15d == 0) ? 1 : 0; 0x00407800 cmp dword [rsp + 0x10], 0xffffffff | 0x00407805 sete cl | cl = (*((rsp + 0x10)) == 0xffffffff) ? 1 : 0; 0x00407808 cmp byte [rsp + 0x28], 0xff | 0x0040780d setne dil | dil = (*((rsp + 0x28)) != 0xff) ? 1 : 0; 0x00407811 cmp byte [rsp + 0x34], 0xff | 0x00407816 setne bl | bl = (*((rsp + 0x34)) != 0xff) ? 1 : 0; 0x00407819 cmp byte [rsp + 0xe], 0xff | 0x0040781e setne al | al = (*((rsp + 0xe)) != 0xff) ? 1 : 0; 0x00407821 cmp bpl, 0xff | 0x00407825 setne dl | dl = (bpl != 0xff) ? 1 : 0; 0x00407828 or dl, byte [rsp + 0x3c] | dl |= *((rsp + 0x3c)); 0x0040782c or dl, al | dl |= al; 0x0040782e or dl, byte [rsp + 0x38] | dl |= *((rsp + 0x38)); 0x00407832 or dl, bl | dl |= bl; 0x00407834 or dl, byte [rsp + 0x24] | dl |= *((rsp + 0x24)); 0x00407838 or dl, dil | dl |= dil; 0x0040783b or dl, byte [rsp + 0x30] | dl |= *((rsp + 0x30)); 0x0040783f and r14b, r13b | r14b &= r13b; 0x00407842 cmp r14b, 0xff | 0x00407846 sete al | al = (r14b == 0xff) ? 1 : 0; 0x00407849 not dl | dl = ~dl; 0x0040784b and cl, sil | cl &= sil; 0x0040784e and r12b, byte [rsp + 0xf] | r12b &= *((rsp + 0xf)); 0x00407853 cmp r12b, 0xff | 0x00407857 sete bl | bl = (r12b == 0xff) ? 1 : 0; 0x0040785a and bl, cl | bl &= cl; 0x0040785c and bl, al | bl &= al; 0x0040785e and bl, dl | bl &= dl; | label_23: 0x00407860 mov eax, ebx | eax = ebx; 0x00407862 add rsp, 0x48 | 0x00407866 pop rbx | 0x00407867 pop r12 | 0x00407869 pop r13 | 0x0040786b pop r14 | 0x0040786d pop r15 | 0x0040786f pop rbp | 0x00407870 ret | return eax; | label_20: 0x00407871 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407875 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407879 test ecx, ecx | | if (ecx != 0) { 0x0040787b je 0x407893 | 0x0040787d lea esi, [rcx + 2] | esi = rcx + 2; 0x00407880 xor edx, edx | edx = 0; 0x00407882 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407884 xor esi, esi | esi = 0; 0x00407886 cmp edx, ecx | 0x00407888 setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040788c imul eax, ecx | eax *= ecx; 0x0040788f add eax, edx | eax += edx; 0x00407891 sub eax, esi | eax -= esi; | } 0x00407893 cmp byte [rsp + 0xd], 0 | 0x00407898 setne r12b | r12b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x0040789c test al, 3 | 0x0040789e sete al | al = ((al & 3) == 0) ? 1 : 0; 0x004078a1 jne 0x4060a6 | | } while ((al & 3) != 0); 0x004078a7 test r12b, r12b | | if (r12b == 0) { 0x004078aa je 0x4060a6 | goto label_0; | } 0x004078b0 mov edi, 0x44f44e | 0x004078b5 mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x004078ba mov esi, 0x24c | esi = 0x24c; 0x004078bf xor eax, eax | eax = 0; 0x004078c1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004078c6 mov eax, dword [rip + 0x2610bc] | eax = (anonymous namespace)::testStatus; 0x004078cc mov r12b, 1 | r12b = 1; 0x004078cf cmp eax, 0x64 | | if (eax <= 0x64) { 0x004078d2 ja 0x4078dc | 0x004078d4 inc eax | eax++; 0x004078d6 mov dword [rip + 0x2610ac], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004078dc mov al, 1 | al = 1; 0x004078de jmp 0x4060a6 | goto label_0; | label_25: 0x004078e3 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x004078e7 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x004078eb test ecx, ecx | | if (ecx != 0) { 0x004078ed je 0x407905 | 0x004078ef lea esi, [rcx + 2] | esi = rcx + 2; 0x004078f2 xor edx, edx | edx = 0; 0x004078f4 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x004078f6 xor esi, esi | esi = 0; 0x004078f8 cmp edx, ecx | 0x004078fa setg sil | sil = (edx > ecx) ? 1 : 0; 0x004078fe imul eax, ecx | eax *= ecx; 0x00407901 add eax, edx | eax += edx; 0x00407903 sub eax, esi | eax -= esi; | } 0x00407905 cmp byte [rsp + 0xd], 0 | 0x0040790a setne r13b | r13b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x0040790e test al, 3 | 0x00407910 sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x00407913 jne 0x40618e | goto label_1; | } 0x00407919 test r13b, r13b | | if (r13b == 0) { 0x0040791c je 0x40618e | goto label_1; | } 0x00407922 mov edi, 0x44f44e | 0x00407927 mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x0040792c mov esi, 0x266 | esi = 0x266; 0x00407931 xor eax, eax | eax = 0; 0x00407933 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407938 mov eax, dword [rip + 0x26104a] | eax = (anonymous namespace)::testStatus; 0x0040793e mov r13b, 1 | r13b = 1; 0x00407941 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00407944 ja 0x40794e | 0x00407946 inc eax | eax++; 0x00407948 mov dword [rip + 0x26103a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040794e mov al, 1 | al = 1; 0x00407950 jmp 0x40618e | goto label_1; | label_30: 0x00407955 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407959 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x0040795d test ecx, ecx | | if (ecx != 0) { 0x0040795f je 0x407977 | 0x00407961 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407964 xor edx, edx | edx = 0; 0x00407966 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407968 xor esi, esi | esi = 0; 0x0040796a cmp edx, ecx | 0x0040796c setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407970 imul eax, ecx | eax *= ecx; 0x00407973 add eax, edx | eax += edx; 0x00407975 sub eax, esi | eax -= esi; | } 0x00407977 cmp byte [rsp + 0xd], 0 | 0x0040797c setne r13b | r13b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x00407980 test al, 3 | 0x00407982 sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x00407985 jne 0x406234 | goto label_2; | } 0x0040798b test r13b, r13b | | if (r13b == 0) { 0x0040798e je 0x406234 | goto label_2; | } 0x00407994 mov edi, 0x44f44e | 0x00407999 mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x0040799e mov esi, 0x281 | esi = 0x281; 0x004079a3 xor eax, eax | eax = 0; 0x004079a5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004079aa mov eax, dword [rip + 0x260fd8] | eax = (anonymous namespace)::testStatus; 0x004079b0 mov r13b, 1 | r13b = 1; 0x004079b3 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004079b6 ja 0x4079c0 | 0x004079b8 inc eax | eax++; 0x004079ba mov dword [rip + 0x260fc8], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004079c0 mov al, 1 | al = 1; 0x004079c2 jmp 0x406234 | goto label_2; | label_35: 0x004079c7 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x004079cb mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x004079cf test ecx, ecx | | if (ecx != 0) { 0x004079d1 je 0x4079e9 | 0x004079d3 lea esi, [rcx + 2] | esi = rcx + 2; 0x004079d6 xor edx, edx | edx = 0; 0x004079d8 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x004079da xor esi, esi | esi = 0; 0x004079dc cmp edx, ecx | 0x004079de setg sil | sil = (edx > ecx) ? 1 : 0; 0x004079e2 imul eax, ecx | eax *= ecx; 0x004079e5 add eax, edx | eax += edx; 0x004079e7 sub eax, esi | eax -= esi; | } 0x004079e9 cmp byte [rsp + 0xd], 0 | 0x004079ee setne r12b | r12b = (*((rsp + 0xd)) != 0) ? 1 : 0; 0x004079f2 test al, 3 | 0x004079f4 sete al | al = ((al & 3) == 0) ? 1 : 0; | if ((al & 3) != 0) { 0x004079f7 jne 0x4062dc | goto label_3; | } 0x004079fd test r12b, r12b | | if (r12b == 0) { 0x00407a00 je 0x4062dc | goto label_3; | } 0x00407a06 mov edi, 0x44f44e | 0x00407a0b mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x00407a10 mov esi, 0x29c | esi = 0x29c; 0x00407a15 xor eax, eax | eax = 0; 0x00407a17 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407a1c mov eax, dword [rip + 0x260f66] | eax = (anonymous namespace)::testStatus; 0x00407a22 mov r12b, 1 | r12b = 1; 0x00407a25 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00407a28 ja 0x407a32 | 0x00407a2a inc eax | eax++; 0x00407a2c mov dword [rip + 0x260f56], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00407a32 mov al, 1 | al = 1; 0x00407a34 jmp 0x4062dc | goto label_3; | label_40: 0x00407a39 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407a3d mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407a41 test ecx, ecx | | if (ecx != 0) { 0x00407a43 je 0x407a5b | 0x00407a45 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407a48 xor edx, edx | edx = 0; 0x00407a4a div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407a4c xor esi, esi | esi = 0; 0x00407a4e cmp edx, ecx | 0x00407a50 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407a54 imul eax, ecx | eax *= ecx; 0x00407a57 add eax, edx | eax += edx; 0x00407a59 sub eax, esi | eax -= esi; | } 0x00407a5b test al, 3 | 0x00407a5d sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407a61 jmp 0x406378 | goto label_4; | label_50: 0x00407a66 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407a6a mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407a6e test ecx, ecx | | if (ecx != 0) { 0x00407a70 je 0x407a88 | 0x00407a72 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407a75 xor edx, edx | edx = 0; 0x00407a77 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407a79 xor esi, esi | esi = 0; 0x00407a7b cmp edx, ecx | 0x00407a7d setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407a81 imul eax, ecx | eax *= ecx; 0x00407a84 add eax, edx | eax += edx; 0x00407a86 sub eax, esi | eax -= esi; | } 0x00407a88 test al, 3 | 0x00407a8a sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407a8e cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407a93 jne 0x406560 | goto label_5; | } 0x00407a99 jmp 0x40658e | goto label_6; | label_54: 0x00407a9e mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407aa2 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407aa6 test ecx, ecx | | if (ecx != 0) { 0x00407aa8 je 0x407ac0 | 0x00407aaa lea esi, [rcx + 2] | esi = rcx + 2; 0x00407aad xor edx, edx | edx = 0; 0x00407aaf div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407ab1 xor esi, esi | esi = 0; 0x00407ab3 cmp edx, ecx | 0x00407ab5 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407ab9 imul eax, ecx | eax *= ecx; 0x00407abc add eax, edx | eax += edx; 0x00407abe sub eax, esi | eax -= esi; | } 0x00407ac0 test al, 3 | 0x00407ac2 sete r12b | r12b = ((al & 3) == 0) ? 1 : 0; 0x00407ac6 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407acb jne 0x4066c0 | goto label_7; | } 0x00407ad1 jmp 0x4066ee | goto label_8; | label_58: 0x00407ad6 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407ada mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407ade test ecx, ecx | | if (ecx != 0) { 0x00407ae0 je 0x407af8 | 0x00407ae2 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407ae5 xor edx, edx | edx = 0; 0x00407ae7 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407ae9 xor esi, esi | esi = 0; 0x00407aeb cmp edx, ecx | 0x00407aed setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407af1 imul eax, ecx | eax *= ecx; 0x00407af4 add eax, edx | eax += edx; 0x00407af6 sub eax, esi | eax -= esi; | } 0x00407af8 test al, 3 | 0x00407afa sete r12b | r12b = ((al & 3) == 0) ? 1 : 0; 0x00407afe cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407b03 jne 0x406820 | goto label_9; | } 0x00407b09 jmp 0x40684e | goto label_10; | label_63: 0x00407b0e mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407b12 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407b16 test ecx, ecx | | if (ecx != 0) { 0x00407b18 je 0x407b30 | 0x00407b1a lea esi, [rcx + 2] | esi = rcx + 2; 0x00407b1d xor edx, edx | edx = 0; 0x00407b1f div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407b21 xor esi, esi | esi = 0; 0x00407b23 cmp edx, ecx | 0x00407b25 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407b29 imul eax, ecx | eax *= ecx; 0x00407b2c add eax, edx | eax += edx; 0x00407b2e sub eax, esi | eax -= esi; | } 0x00407b30 test al, 3 | 0x00407b32 sete bpl | bpl = ((al & 3) == 0) ? 1 : 0; 0x00407b36 cmp byte [rsp + 0xd], 0 | | if (*((rsp + 0xd)) != 0) { 0x00407b3b jne 0x406985 | goto label_11; | } 0x00407b41 jmp 0x4069b3 | goto label_12; | label_67: 0x00407b46 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407b4a mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407b4e test ecx, ecx | | if (ecx != 0) { 0x00407b50 je 0x407b68 | 0x00407b52 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407b55 xor edx, edx | edx = 0; 0x00407b57 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407b59 xor esi, esi | esi = 0; 0x00407b5b cmp edx, ecx | 0x00407b5d setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407b61 imul eax, ecx | eax *= ecx; 0x00407b64 add eax, edx | eax += edx; 0x00407b66 sub eax, esi | eax -= esi; | } 0x00407b68 test al, 3 | 0x00407b6a sete r13b | r13b = ((al & 3) == 0) ? 1 : 0; 0x00407b6e mov eax, r13d | eax = r13d; 0x00407b71 and al, bl | al &= bl; 0x00407b73 cmp al, 1 | | if (al != 1) { 0x00407b75 jne 0x406ab2 | goto label_13; | } 0x00407b7b mov edi, 0x44f44e | 0x00407b80 mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x00407b85 mov esi, 0x2bf | esi = 0x2bf; 0x00407b8a xor eax, eax | eax = 0; 0x00407b8c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407b91 mov eax, dword [rip + 0x260df1] | eax = (anonymous namespace)::testStatus; 0x00407b97 mov r13b, 1 | r13b = 1; 0x00407b9a cmp eax, 0x64 | | if (eax > 0x64) { 0x00407b9d ja 0x406ab2 | goto label_13; | } 0x00407ba3 inc eax | eax++; 0x00407ba5 mov dword [rip + 0x260ddd], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407bab jmp 0x406ab2 | goto label_13; | label_46: 0x00407bb0 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407bb4 mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407bb8 test ecx, ecx | | if (ecx != 0) { 0x00407bba je 0x407bd2 | 0x00407bbc lea esi, [rcx + 2] | esi = rcx + 2; 0x00407bbf xor edx, edx | edx = 0; 0x00407bc1 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407bc3 xor esi, esi | esi = 0; 0x00407bc5 cmp edx, ecx | 0x00407bc7 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407bcb imul eax, ecx | eax *= ecx; 0x00407bce add eax, edx | eax += edx; 0x00407bd0 sub eax, esi | eax -= esi; | } 0x00407bd2 test al, 3 | 0x00407bd4 sete bl | bl = ((al & 3) == 0) ? 1 : 0; 0x00407bd7 mov eax, ebx | eax = ebx; 0x00407bd9 and al, r12b | al &= r12b; 0x00407bdc cmp al, 1 | | if (al != 1) { 0x00407bde jne 0x40645b | goto label_14; | } 0x00407be4 mov edi, 0x44f44e | 0x00407be9 mov edx, 0x44d533 | edx = "a1 || !enabled"; 0x00407bee mov esi, 0x2d1 | esi = 0x2d1; 0x00407bf3 xor eax, eax | eax = 0; 0x00407bf5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407bfa mov eax, dword [rip + 0x260d88] | eax = (anonymous namespace)::testStatus; 0x00407c00 mov bl, 1 | bl = 1; 0x00407c02 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407c05 ja 0x40645b | goto label_14; | } 0x00407c0b inc eax | eax++; 0x00407c0d mov dword [rip + 0x260d75], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407c13 jmp 0x40645b | goto label_14; | label_105: 0x00407c18 mov ecx, dword [r14 + 4] | ecx = *((r14 + 4)); 0x00407c1c mov eax, dword [r14 + 0xc] | eax = *((r14 + 0xc)); 0x00407c20 test ecx, ecx | | if (ecx != 0) { 0x00407c22 je 0x407c3a | 0x00407c24 lea esi, [rcx + 2] | esi = rcx + 2; 0x00407c27 xor edx, edx | edx = 0; 0x00407c29 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00407c2b xor esi, esi | esi = 0; 0x00407c2d cmp edx, ecx | 0x00407c2f setg sil | sil = (edx > ecx) ? 1 : 0; 0x00407c33 imul eax, ecx | eax *= ecx; 0x00407c36 add eax, edx | eax += edx; 0x00407c38 sub eax, esi | eax -= esi; | } 0x00407c3a test al, 3 | 0x00407c3c sete al | al = ((al & 3) == 0) ? 1 : 0; 0x00407c3f mov dword [rsp + 0x24], eax | *((rsp + 0x24)) = eax; 0x00407c43 and al, r12b | al &= r12b; 0x00407c46 cmp al, 1 | | if (al != 1) { 0x00407c48 jne 0x407609 | goto label_15; | } 0x00407c4e mov edi, 0x44f44e | 0x00407c53 mov edx, 0x44d56f | edx = "b1 || !enabled"; 0x00407c58 mov esi, 0x2d9 | esi = 0x2d9; 0x00407c5d xor eax, eax | eax = 0; 0x00407c5f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00407c64 mov eax, dword [rip + 0x260d1e] | eax = (anonymous namespace)::testStatus; 0x00407c6a mov cl, 1 | cl = 1; 0x00407c6c mov dword [rsp + 0x24], ecx | *((rsp + 0x24)) = ecx; 0x00407c70 cmp eax, 0x64 | | if (eax > 0x64) { 0x00407c73 ja 0x407609 | goto label_15; | } 0x00407c79 inc eax | eax++; 0x00407c7b mov dword [rip + 0x260d07], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x00407c81 jmp 0x407609 | goto label_15; | }