; assembly | /* r2dec pseudo code output */ | /* bdlde_base64encoder.t/assume @ 0x405130 */ | #include | ; (fcn) sym.setState_BloombergLP::bdlde::Base64Encoder__int_ () | uint64_t setState_BloombergLP::bdlde::Base64Encoder_int_ (uint32_t arg2, uint32_t arg1) { | int64_t var_fh; | uint32_t var_10h; | uint32_t var_14h; | int64_t var_18h; | rsi = arg2; | rdi = arg1; | /* setState(BloombergLP::bdlde::Base64Encoder*, int) */ 0x00405130 push rbp | 0x00405131 push r15 | 0x00405133 push r14 | 0x00405135 push r12 | 0x00405137 push rbx | 0x00405138 sub rsp, 0x20 | 0x0040513c mov r12d, esi | r12d = esi; 0x0040513f mov r15, rdi | r15 = rdi; 0x00405142 test rdi, rdi | | if (rdi == 0) { 0x00405145 jne 0x405170 | 0x00405147 mov edi, 0x44f44e | 0x0040514c mov edx, 0x44d2bd | edx = "object"; 0x00405151 mov esi, 0x1bd | esi = 0x1bd; 0x00405156 xor eax, eax | eax = 0; 0x00405158 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040515d mov eax, dword [rip + 0x263825] | eax = (anonymous namespace)::testStatus; 0x00405163 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405166 ja 0x405170 | goto label_6; | } 0x00405168 inc eax | eax++; 0x0040516a mov dword [rip + 0x263818], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_6: 0x00405170 test r12d, r12d | | if (r12d >= 0) { 0x00405173 js 0x405187 | 0x00405175 cmp r12d, 6 | | if (r12d < 6) { 0x00405179 jl 0x4051b0 | goto label_7; | } 0x0040517b mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405180 mov edx, 0x44d2cf | edx = "state < NUM_STATES"; 0x00405185 jmp 0x405191 | | } else { 0x00405187 mov edi, 0x44f44e | 0x0040518c mov edx, 0x44d2c4 | edx = "0 <= state"; | } 0x00405191 mov esi, 0x1bd | esi = 0x1bd; 0x00405196 xor eax, eax | eax = 0; 0x00405198 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040519d mov eax, dword [rip + 0x2637e5] | eax = (anonymous namespace)::testStatus; 0x004051a3 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004051a6 ja 0x4051b0 | 0x004051a8 inc eax | eax++; 0x004051aa mov dword [rip + 0x2637d8], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_7: 0x004051b0 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x004051b5 jne 0x4051c1 | 0x004051b7 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x004051bb je 0x40529a | goto label_8; | } | } 0x004051c1 mov edi, 0x6688c8 | 0x004051c6 mov esi, 0x44d2e2 | 0x004051cb mov edx, 0x3d | 0x004051d0 call 0x423680 | rax = std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (obj.std::__1::cout, "You must not call 'setState' from other than 'INITIAL_STATE'!", 0x3d); 0x004051d5 mov rbx, rax | rbx = rax; 0x004051d8 mov rax, qword [rax] | rax = *(rax); 0x004051db mov rsi, qword [rax - 0x18] | rsi = *((rax - 0x18)); 0x004051df add rsi, rbx | rsi += rbx; 0x004051e2 lea rbp, [rsp + 0x18] | rbp = rsp + 0x18; 0x004051e7 mov rdi, rbp | rdi = rbp; 0x004051ea call 0x404ab0 | std::_1::ios_base::getloc()const (); 0x004051ef mov esi, 0x668810 | esi = std::__1::ctype::id; 0x004051f4 mov rdi, rbp | rdi = rbp; 0x004051f7 call 0x404b70 | rax = std::_1::locale::use_facet(std::_1::locale::id&)const (); 0x004051fc mov rcx, qword [rax] | rcx = *(rax); 0x004051ff mov rdi, rax | rdi = rax; 0x00405202 mov esi, 0xa | esi = 0xa; 0x00405207 call qword [rcx + 0x38] | eax = uint64_t (*rcx + 0x38)() (); 0x0040520a mov r14d, eax | r14d = eax; 0x0040520d lea rdi, [rsp + 0x18] | rdi = rsp + 0x18; 0x00405212 call 0x404c00 | std::_1::locale::~locale() (); 0x00405217 movsx esi, r14b | esi = (int32_t) r14b; 0x0040521b mov rdi, rbx | rdi = rbx; 0x0040521e call 0x4048a0 | std::_1::basic_ostream>::put(char) (); 0x00405223 mov rdi, rbx | rdi = rbx; 0x00405226 call 0x404a70 | std::_1::basic_ostream>::flush() (); 0x0040522b mov esi, 0x44d320 | 0x00405230 mov edx, 0x3b | 0x00405235 mov rdi, rbx | 0x00405238 call 0x423680 | rax = std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (rbx, "\tNote that '::isState' *will* alter from the initial state.", 0x3b); 0x0040523d mov rbx, rax | rbx = rax; 0x00405240 mov rax, qword [rax] | rax = *(rax); 0x00405243 mov rsi, qword [rax - 0x18] | rsi = *((rax - 0x18)); 0x00405247 add rsi, rbx | rsi += rbx; 0x0040524a lea rbp, [rsp + 0x18] | rbp = rsp + 0x18; 0x0040524f mov rdi, rbp | rdi = rbp; 0x00405252 call 0x404ab0 | std::_1::ios_base::getloc()const (); 0x00405257 mov esi, 0x668810 | esi = std::__1::ctype::id; 0x0040525c mov rdi, rbp | rdi = rbp; 0x0040525f call 0x404b70 | rax = std::_1::locale::use_facet(std::_1::locale::id&)const (); 0x00405264 mov rcx, qword [rax] | rcx = *(rax); 0x00405267 mov rdi, rax | rdi = rax; 0x0040526a mov esi, 0xa | esi = 0xa; 0x0040526f call qword [rcx + 0x38] | eax = uint64_t (*rcx + 0x38)() (); 0x00405272 mov r14d, eax | r14d = eax; 0x00405275 lea rdi, [rsp + 0x18] | rdi = rsp + 0x18; 0x0040527a call 0x404c00 | std::_1::locale::~locale() (); 0x0040527f movsx esi, r14b | esi = (int32_t) r14b; 0x00405283 mov rdi, rbx | rdi = rbx; 0x00405286 call 0x4048a0 | std::_1::basic_ostream>::put(char) (); 0x0040528b mov rdi, rbx | rdi = rbx; 0x0040528e call 0x404a70 | eax = std::_1::basic_ostream>::flush() (); 0x00405293 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x00405298 jne 0x4052a0 | | label_8: 0x0040529a cmp byte [r15], 0 | | if (*(r15) == 0) { 0x0040529e je 0x4052c9 | goto label_9; | } | } 0x004052a0 mov edi, 0x44f44e | 0x004052a5 mov edx, 0x44d430 | edx = 0x44d430; 0x004052aa mov esi, 0x1c4 | esi = 0x1c4; 0x004052af xor eax, eax | eax = 0; 0x004052b1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004052b6 mov eax, dword [rip + 0x2636cc] | eax = (anonymous namespace)::testStatus; 0x004052bc cmp eax, 0x64 | | if (eax <= 0x64) { 0x004052bf ja 0x4052c9 | 0x004052c1 inc eax | eax++; 0x004052c3 mov dword [rip + 0x2636bf], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_9: 0x004052c9 mov dword [rsp + 0x10], 0xffffffff | *((rsp + 0x10)) = 0xffffffff; 0x004052d1 mov dword [rsp + 0x14], 0xffffffff | *((rsp + 0x14)) = 0xffffffff; 0x004052d9 mov byte [rsp + 0xf], 0 | *((rsp + 0xf)) = 0; 0x004052de cmp r12d, 5 | | if (r12d <= 5) { 0x004052e2 ja 0x40540c | 0x004052e8 lea r14, [rsp + 0x10] | r14 = rsp + 0x10; 0x004052ed mov eax, r12d | eax = r12d; | /* switch table (6 cases) at 0x449b90 */ 0x004052f0 jmp qword [rax*8 + 0x449b90] | 0x004052f7 mov al, byte [r15] | al = *(r15); 0x004052fa cmp al, 0xff | | if (al == 0xff) { 0x004052fc jne 0x40532a | 0x004052fe mov edi, 0x44f44e | 0x00405303 mov edx, 0x44d35c | edx = "1 == object->isAcceptable()"; 0x00405308 mov esi, 0x1d1 | esi = 0x1d1; 0x0040530d xor eax, eax | eax = 0; 0x0040530f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405314 mov eax, dword [rip + 0x26366e] | eax = (anonymous namespace)::testStatus; 0x0040531a cmp eax, 0x64 | | if (eax <= 0x64) { 0x0040531d ja 0x405327 | 0x0040531f inc eax | eax++; 0x00405321 mov dword [rip + 0x263661], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405327 mov al, byte [r15] | al = *(r15); | } 0x0040532a cmp al, 1 | | if (al == 1) { 0x0040532c jne 0x405384 | 0x0040532e cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x00405333 jne 0x405384 | goto label_10; | } 0x00405335 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405339 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x0040533d test ecx, ecx | | if (ecx != 0) { 0x0040533f je 0x405357 | 0x00405341 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405344 xor edx, edx | edx = 0; 0x00405346 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405348 xor esi, esi | esi = 0; 0x0040534a cmp edx, ecx | 0x0040534c setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405350 imul eax, ecx | eax *= ecx; 0x00405353 add eax, edx | eax += edx; 0x00405355 sub eax, esi | eax -= esi; | } 0x00405357 test al, 3 | | if ((al & 3) != 0) { 0x00405359 jne 0x405384 | goto label_10; | } 0x0040535b mov edi, 0x44f44e | 0x00405360 mov edx, 0x44d378 | edx = "0 == object->isDone()"; 0x00405365 mov esi, 0x1d2 | esi = 0x1d2; 0x0040536a xor eax, eax | eax = 0; 0x0040536c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405371 mov eax, dword [rip + 0x263611] | eax = (anonymous namespace)::testStatus; 0x00405377 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040537a ja 0x405384 | goto label_10; | } 0x0040537c inc eax | eax++; 0x0040537e mov dword [rip + 0x263604], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x00405384 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405388 jne 0x4053b3 | 0x0040538a mov edi, 0x44f44e | 0x0040538f mov edx, 0x44d38e | edx = "0 == object->isError()"; 0x00405394 mov esi, 0x1d3 | esi = 0x1d3; 0x00405399 xor eax, eax | eax = 0; 0x0040539b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004053a0 mov eax, dword [rip + 0x2635e2] | eax = (anonymous namespace)::testStatus; 0x004053a6 cmp eax, 0x64 | | if (eax > 0x64) { 0x004053a9 ja 0x4053b3 | goto label_11; | } 0x004053ab inc eax | eax++; 0x004053ad mov dword [rip + 0x2635d5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_11: 0x004053b3 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x004053b8 jne 0x4053c4 | 0x004053ba cmp byte [r15], 0 | | if (*(r15) == 0) { 0x004053be je 0x405e3a | goto label_1; | } | } 0x004053c4 mov edi, 0x44f44e | 0x004053c9 mov edx, 0x44d3a5 | edx = "1 == object->isInitialState()"; 0x004053ce mov esi, 0x1d4 | esi = 0x1d4; 0x004053d3 xor eax, eax | eax = 0; 0x004053d5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004053da mov eax, dword [rip + 0x2635a8] | eax = (anonymous namespace)::testStatus; 0x004053e0 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004053e3 ja 0x4053ed | 0x004053e5 inc eax | eax++; 0x004053e7 mov dword [rip + 0x26359b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004053ed cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x004053f2 je 0x405e3a | goto label_1; | } 0x004053f8 mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004053fd mov edx, 0x44d3c3 | edx = "0 == object->outputLength()"; 0x00405402 mov esi, 0x1d5 | esi = 0x1d5; 0x00405407 jmp 0x405e20 | | } else { 0x0040540c mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405411 mov edx, 0x44d50f | edx = "\"Unknown State\" && 0"; 0x00405416 mov esi, 0x216 | esi = 0x216; 0x0040541b jmp 0x405e20 | goto label_12; 0x00405420 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405427 lea rsi, [rsp + 0x18] | 0x0040542c lea rdx, [rsp + 0x10] | 0x00405431 lea rcx, [rsp + 0x14] | 0x00405436 lea r8, [rsp + 0xf] | 0x0040543b mov rdi, r15 | 0x0040543e mov r9, r14 | 0x00405441 call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x00405446 test eax, eax | | if (eax != 0) { 0x00405448 je 0x405473 | 0x0040544a mov edi, 0x44f44e | 0x0040544f mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x00405454 mov esi, 0x1d8 | esi = 0x1d8; 0x00405459 xor eax, eax | eax = 0; 0x0040545b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405460 mov eax, dword [rip + 0x263522] | eax = (anonymous namespace)::testStatus; 0x00405466 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405469 ja 0x405473 | goto label_13; | } 0x0040546b inc eax | eax++; 0x0040546d mov dword [rip + 0x263515], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_13: 0x00405473 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x00405478 je 0x4054a3 | 0x0040547a mov edi, 0x44f44e | 0x0040547f mov edx, 0x44d414 | edx = "1 == numOut"; 0x00405484 mov esi, 0x1d9 | esi = 0x1d9; 0x00405489 xor eax, eax | eax = 0; 0x0040548b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405490 mov eax, dword [rip + 0x2634f2] | eax = (anonymous namespace)::testStatus; 0x00405496 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405499 ja 0x4054a3 | goto label_14; | } 0x0040549b inc eax | eax++; 0x0040549d mov dword [rip + 0x2634e5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_14: 0x004054a3 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004054a8 je 0x4054d3 | 0x004054aa mov edi, 0x44f44e | 0x004054af mov edx, 0x44d420 | edx = "1 == numIn"; 0x004054b4 mov esi, 0x1d9 | esi = 0x1d9; 0x004054b9 xor eax, eax | eax = 0; 0x004054bb call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004054c0 mov eax, dword [rip + 0x2634c2] | eax = (anonymous namespace)::testStatus; 0x004054c6 cmp eax, 0x64 | | if (eax > 0x64) { 0x004054c9 ja 0x4054d3 | goto label_15; | } 0x004054cb inc eax | eax++; 0x004054cd mov dword [rip + 0x2634b5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_15: 0x004054d3 mov al, byte [r15] | al = *(r15); 0x004054d6 cmp al, 0xff | | if (al == 0xff) { 0x004054d8 jne 0x405506 | 0x004054da mov edi, 0x44f44e | 0x004054df mov edx, 0x44d35c | edx = "1 == object->isAcceptable()"; 0x004054e4 mov esi, 0x1db | esi = 0x1db; 0x004054e9 xor eax, eax | eax = 0; 0x004054eb call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004054f0 mov eax, dword [rip + 0x263492] | eax = (anonymous namespace)::testStatus; 0x004054f6 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004054f9 ja 0x405503 | 0x004054fb inc eax | eax++; 0x004054fd mov dword [rip + 0x263485], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405503 mov al, byte [r15] | al = *(r15); | } 0x00405506 cmp al, 1 | | if (al == 1) { 0x00405508 jne 0x405560 | 0x0040550a cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x0040550f jne 0x405560 | goto label_16; | } 0x00405511 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405515 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405519 test ecx, ecx | | if (ecx != 0) { 0x0040551b je 0x405533 | 0x0040551d lea esi, [rcx + 2] | esi = rcx + 2; 0x00405520 xor edx, edx | edx = 0; 0x00405522 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405524 xor esi, esi | esi = 0; 0x00405526 cmp edx, ecx | 0x00405528 setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040552c imul eax, ecx | eax *= ecx; 0x0040552f add eax, edx | eax += edx; 0x00405531 sub eax, esi | eax -= esi; | } 0x00405533 test al, 3 | | if ((al & 3) != 0) { 0x00405535 jne 0x405560 | goto label_16; | } 0x00405537 mov edi, 0x44f44e | 0x0040553c mov edx, 0x44d378 | edx = "0 == object->isDone()"; 0x00405541 mov esi, 0x1dc | esi = 0x1dc; 0x00405546 xor eax, eax | eax = 0; 0x00405548 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040554d mov eax, dword [rip + 0x263435] | eax = (anonymous namespace)::testStatus; 0x00405553 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405556 ja 0x405560 | goto label_16; | } 0x00405558 inc eax | eax++; 0x0040555a mov dword [rip + 0x263428], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_16: 0x00405560 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405564 jne 0x40558f | 0x00405566 mov edi, 0x44f44e | 0x0040556b mov edx, 0x44d38e | edx = "0 == object->isError()"; 0x00405570 mov esi, 0x1dd | esi = 0x1dd; 0x00405575 xor eax, eax | eax = 0; 0x00405577 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040557c mov eax, dword [rip + 0x263406] | eax = (anonymous namespace)::testStatus; 0x00405582 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405585 ja 0x40558f | goto label_17; | } 0x00405587 inc eax | eax++; 0x00405589 mov dword [rip + 0x2633f9], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_17: 0x0040558f cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405594 jne 0x405e3a | goto label_1; | } 0x0040559a cmp byte [r15], 0 | | if (*(r15) == 0) { 0x0040559e je 0x405ec2 | goto label_18; | } | label_3: 0x004055a4 mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004055a9 mov edx, 0x44d449 | edx = "0 != object->outputLength()"; 0x004055ae mov esi, 0x1df | esi = 0x1df; 0x004055b3 jmp 0x405e20 | goto label_12; 0x004055b8 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004055bf lea rsi, [rsp + 0x18] | 0x004055c4 lea rdx, [rsp + 0x10] | 0x004055c9 lea rcx, [rsp + 0x14] | 0x004055ce lea r8, [rsp + 0xf] | 0x004055d3 mov rdi, r15 | 0x004055d6 mov r9, r14 | 0x004055d9 call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x004055de test eax, eax | | if (eax != 0) { 0x004055e0 je 0x40560b | 0x004055e2 mov edi, 0x44f44e | 0x004055e7 mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x004055ec mov esi, 0x1e2 | esi = 0x1e2; 0x004055f1 xor eax, eax | eax = 0; 0x004055f3 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004055f8 mov eax, dword [rip + 0x26338a] | eax = (anonymous namespace)::testStatus; 0x004055fe cmp eax, 0x64 | | if (eax > 0x64) { 0x00405601 ja 0x40560b | goto label_19; | } 0x00405603 inc eax | eax++; 0x00405605 mov dword [rip + 0x26337d], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_19: 0x0040560b cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x00405610 je 0x40563b | 0x00405612 mov edi, 0x44f44e | 0x00405617 mov edx, 0x44d414 | edx = "1 == numOut"; 0x0040561c mov esi, 0x1e3 | esi = 0x1e3; 0x00405621 xor eax, eax | eax = 0; 0x00405623 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405628 mov eax, dword [rip + 0x26335a] | eax = (anonymous namespace)::testStatus; 0x0040562e cmp eax, 0x64 | | if (eax > 0x64) { 0x00405631 ja 0x40563b | goto label_20; | } 0x00405633 inc eax | eax++; 0x00405635 mov dword [rip + 0x26334d], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_20: 0x0040563b cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x00405640 je 0x40566b | 0x00405642 mov edi, 0x44f44e | 0x00405647 mov edx, 0x44d420 | edx = "1 == numIn"; 0x0040564c mov esi, 0x1e3 | esi = 0x1e3; 0x00405651 xor eax, eax | eax = 0; 0x00405653 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405658 mov eax, dword [rip + 0x26332a] | eax = (anonymous namespace)::testStatus; 0x0040565e cmp eax, 0x64 | | if (eax > 0x64) { 0x00405661 ja 0x40566b | goto label_21; | } 0x00405663 inc eax | eax++; 0x00405665 mov dword [rip + 0x26331d], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_21: 0x0040566b mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405672 lea rsi, [rsp + 0x18] | 0x00405677 lea rdx, [rsp + 0x10] | 0x0040567c lea rcx, [rsp + 0x14] | 0x00405681 lea r8, [rsp + 0xf] | 0x00405686 mov rdi, r15 | 0x00405689 mov r9, r14 | 0x0040568c call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x00405691 test eax, eax | | if (eax != 0) { 0x00405693 je 0x4056be | 0x00405695 mov edi, 0x44f44e | 0x0040569a mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x0040569f mov esi, 0x1e5 | esi = 0x1e5; 0x004056a4 xor eax, eax | eax = 0; 0x004056a6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004056ab mov eax, dword [rip + 0x2632d7] | eax = (anonymous namespace)::testStatus; 0x004056b1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004056b4 ja 0x4056be | goto label_22; | } 0x004056b6 inc eax | eax++; 0x004056b8 mov dword [rip + 0x2632ca], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_22: 0x004056be cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x004056c3 je 0x4056ee | 0x004056c5 mov edi, 0x44f44e | 0x004056ca mov edx, 0x44d414 | edx = "1 == numOut"; 0x004056cf mov esi, 0x1e6 | esi = 0x1e6; 0x004056d4 xor eax, eax | eax = 0; 0x004056d6 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004056db mov eax, dword [rip + 0x2632a7] | eax = (anonymous namespace)::testStatus; 0x004056e1 cmp eax, 0x64 | | if (eax > 0x64) { 0x004056e4 ja 0x4056ee | goto label_23; | } 0x004056e6 inc eax | eax++; 0x004056e8 mov dword [rip + 0x26329a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_23: 0x004056ee cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004056f3 je 0x40571e | 0x004056f5 mov edi, 0x44f44e | 0x004056fa mov edx, 0x44d420 | edx = "1 == numIn"; 0x004056ff mov esi, 0x1e6 | esi = 0x1e6; 0x00405704 xor eax, eax | eax = 0; 0x00405706 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040570b mov eax, dword [rip + 0x263277] | eax = (anonymous namespace)::testStatus; 0x00405711 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405714 ja 0x40571e | goto label_24; | } 0x00405716 inc eax | eax++; 0x00405718 mov dword [rip + 0x26326a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_24: 0x0040571e mov al, byte [r15] | al = *(r15); 0x00405721 cmp al, 0xff | | if (al == 0xff) { 0x00405723 jne 0x405751 | 0x00405725 mov edi, 0x44f44e | 0x0040572a mov edx, 0x44d35c | edx = "1 == object->isAcceptable()"; 0x0040572f mov esi, 0x1e8 | esi = 0x1e8; 0x00405734 xor eax, eax | eax = 0; 0x00405736 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040573b mov eax, dword [rip + 0x263247] | eax = (anonymous namespace)::testStatus; 0x00405741 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405744 ja 0x40574e | 0x00405746 inc eax | eax++; 0x00405748 mov dword [rip + 0x26323a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040574e mov al, byte [r15] | al = *(r15); | } 0x00405751 cmp al, 1 | | if (al == 1) { 0x00405753 jne 0x4057ab | 0x00405755 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x0040575a jne 0x4057ab | goto label_25; | } 0x0040575c mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405760 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405764 test ecx, ecx | | if (ecx != 0) { 0x00405766 je 0x40577e | 0x00405768 lea esi, [rcx + 2] | esi = rcx + 2; 0x0040576b xor edx, edx | edx = 0; 0x0040576d div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x0040576f xor esi, esi | esi = 0; 0x00405771 cmp edx, ecx | 0x00405773 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405777 imul eax, ecx | eax *= ecx; 0x0040577a add eax, edx | eax += edx; 0x0040577c sub eax, esi | eax -= esi; | } 0x0040577e test al, 3 | | if ((al & 3) != 0) { 0x00405780 jne 0x4057ab | goto label_25; | } 0x00405782 mov edi, 0x44f44e | 0x00405787 mov edx, 0x44d378 | edx = "0 == object->isDone()"; 0x0040578c mov esi, 0x1e9 | esi = 0x1e9; 0x00405791 xor eax, eax | eax = 0; 0x00405793 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405798 mov eax, dword [rip + 0x2631ea] | eax = (anonymous namespace)::testStatus; 0x0040579e cmp eax, 0x64 | | if (eax > 0x64) { 0x004057a1 ja 0x4057ab | goto label_25; | } 0x004057a3 inc eax | eax++; 0x004057a5 mov dword [rip + 0x2631dd], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_25: 0x004057ab cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x004057af jne 0x4057da | 0x004057b1 mov edi, 0x44f44e | 0x004057b6 mov edx, 0x44d38e | edx = "0 == object->isError()"; 0x004057bb mov esi, 0x1ea | esi = 0x1ea; 0x004057c0 xor eax, eax | eax = 0; 0x004057c2 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004057c7 mov eax, dword [rip + 0x2631bb] | eax = (anonymous namespace)::testStatus; 0x004057cd cmp eax, 0x64 | | if (eax > 0x64) { 0x004057d0 ja 0x4057da | goto label_26; | } 0x004057d2 inc eax | eax++; 0x004057d4 mov dword [rip + 0x2631ae], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_26: 0x004057da cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x004057df jne 0x405e3a | goto label_1; | } 0x004057e5 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x004057e9 je 0x405efb | goto label_27; | } | label_4: 0x004057ef mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004057f4 mov edx, 0x44d449 | edx = "0 != object->outputLength()"; 0x004057f9 mov esi, 0x1ec | esi = 0x1ec; 0x004057fe jmp 0x405e20 | goto label_12; 0x00405803 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040580a lea rsi, [rsp + 0x18] | 0x0040580f lea rdx, [rsp + 0x10] | 0x00405814 lea rcx, [rsp + 0x14] | 0x00405819 lea r8, [rsp + 0xf] | 0x0040581e mov rdi, r15 | 0x00405821 mov r9, r14 | 0x00405824 call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x00405829 test eax, eax | | if (eax != 0) { 0x0040582b je 0x405856 | 0x0040582d mov edi, 0x44f44e | 0x00405832 mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x00405837 mov esi, 0x1ef | esi = 0x1ef; 0x0040583c xor eax, eax | eax = 0; 0x0040583e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405843 mov eax, dword [rip + 0x26313f] | eax = (anonymous namespace)::testStatus; 0x00405849 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040584c ja 0x405856 | goto label_28; | } 0x0040584e inc eax | eax++; 0x00405850 mov dword [rip + 0x263132], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x00405856 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x0040585b je 0x405886 | 0x0040585d mov edi, 0x44f44e | 0x00405862 mov edx, 0x44d414 | edx = "1 == numOut"; 0x00405867 mov esi, 0x1f0 | esi = 0x1f0; 0x0040586c xor eax, eax | eax = 0; 0x0040586e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405873 mov eax, dword [rip + 0x26310f] | eax = (anonymous namespace)::testStatus; 0x00405879 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040587c ja 0x405886 | goto label_29; | } 0x0040587e inc eax | eax++; 0x00405880 mov dword [rip + 0x263102], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_29: 0x00405886 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x0040588b je 0x4058b6 | 0x0040588d mov edi, 0x44f44e | 0x00405892 mov edx, 0x44d420 | edx = "1 == numIn"; 0x00405897 mov esi, 0x1f0 | esi = 0x1f0; 0x0040589c xor eax, eax | eax = 0; 0x0040589e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004058a3 mov eax, dword [rip + 0x2630df] | eax = (anonymous namespace)::testStatus; 0x004058a9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004058ac ja 0x4058b6 | goto label_30; | } 0x004058ae inc eax | eax++; 0x004058b0 mov dword [rip + 0x2630d2], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_30: 0x004058b6 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004058bd lea rsi, [rsp + 0x18] | 0x004058c2 lea rdx, [rsp + 0x10] | 0x004058c7 lea rcx, [rsp + 0x14] | 0x004058cc lea r8, [rsp + 0xf] | 0x004058d1 mov rdi, r15 | 0x004058d4 mov r9, r14 | 0x004058d7 call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x004058dc test eax, eax | | if (eax != 0) { 0x004058de je 0x405909 | 0x004058e0 mov edi, 0x44f44e | 0x004058e5 mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x004058ea mov esi, 0x1f2 | esi = 0x1f2; 0x004058ef xor eax, eax | eax = 0; 0x004058f1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004058f6 mov eax, dword [rip + 0x26308c] | eax = (anonymous namespace)::testStatus; 0x004058fc cmp eax, 0x64 | | if (eax > 0x64) { 0x004058ff ja 0x405909 | goto label_31; | } 0x00405901 inc eax | eax++; 0x00405903 mov dword [rip + 0x26307f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_31: 0x00405909 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x0040590e je 0x405939 | 0x00405910 mov edi, 0x44f44e | 0x00405915 mov edx, 0x44d414 | edx = "1 == numOut"; 0x0040591a mov esi, 0x1f3 | esi = 0x1f3; 0x0040591f xor eax, eax | eax = 0; 0x00405921 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405926 mov eax, dword [rip + 0x26305c] | eax = (anonymous namespace)::testStatus; 0x0040592c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040592f ja 0x405939 | goto label_32; | } 0x00405931 inc eax | eax++; 0x00405933 mov dword [rip + 0x26304f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_32: 0x00405939 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x0040593e je 0x405969 | 0x00405940 mov edi, 0x44f44e | 0x00405945 mov edx, 0x44d420 | edx = "1 == numIn"; 0x0040594a mov esi, 0x1f3 | esi = 0x1f3; 0x0040594f xor eax, eax | eax = 0; 0x00405951 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405956 mov eax, dword [rip + 0x26302c] | eax = (anonymous namespace)::testStatus; 0x0040595c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040595f ja 0x405969 | goto label_33; | } 0x00405961 inc eax | eax++; 0x00405963 mov dword [rip + 0x26301f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x00405969 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405970 lea rsi, [rsp + 0x18] | 0x00405975 lea rdx, [rsp + 0x10] | 0x0040597a lea rcx, [rsp + 0x14] | 0x0040597f lea r8, [rsp + 0xf] | 0x00405984 mov rdi, r15 | 0x00405987 mov r9, r14 | 0x0040598a call 0x421500 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x0040598f test eax, eax | | if (eax != 0) { 0x00405991 je 0x4059bc | 0x00405993 mov edi, 0x44f44e | 0x00405998 mov edx, 0x44d3df | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x0040599d mov esi, 0x1f5 | esi = 0x1f5; 0x004059a2 xor eax, eax | eax = 0; 0x004059a4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004059a9 mov eax, dword [rip + 0x262fd9] | eax = (anonymous namespace)::testStatus; 0x004059af cmp eax, 0x64 | | if (eax > 0x64) { 0x004059b2 ja 0x4059bc | goto label_34; | } 0x004059b4 inc eax | eax++; 0x004059b6 mov dword [rip + 0x262fcc], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_34: 0x004059bc cmp dword [rsp + 0x10], 2 | | if (*((rsp + 0x10)) != 2) { 0x004059c1 je 0x4059ec | 0x004059c3 mov edi, 0x44f44e | 0x004059c8 mov edx, 0x44d465 | edx = "2 == numOut"; 0x004059cd mov esi, 0x1f6 | esi = 0x1f6; 0x004059d2 xor eax, eax | eax = 0; 0x004059d4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004059d9 mov eax, dword [rip + 0x262fa9] | eax = (anonymous namespace)::testStatus; 0x004059df cmp eax, 0x64 | | if (eax > 0x64) { 0x004059e2 ja 0x4059ec | goto label_35; | } 0x004059e4 inc eax | eax++; 0x004059e6 mov dword [rip + 0x262f9c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_35: 0x004059ec cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004059f1 je 0x405a1c | 0x004059f3 mov edi, 0x44f44e | 0x004059f8 mov edx, 0x44d420 | edx = "1 == numIn"; 0x004059fd mov esi, 0x1f6 | esi = 0x1f6; 0x00405a02 xor eax, eax | eax = 0; 0x00405a04 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a09 mov eax, dword [rip + 0x262f79] | eax = (anonymous namespace)::testStatus; 0x00405a0f cmp eax, 0x64 | | if (eax > 0x64) { 0x00405a12 ja 0x405a1c | goto label_36; | } 0x00405a14 inc eax | eax++; 0x00405a16 mov dword [rip + 0x262f6c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_36: 0x00405a1c mov al, byte [r15] | al = *(r15); 0x00405a1f cmp al, 0xff | | if (al == 0xff) { 0x00405a21 jne 0x405a4f | 0x00405a23 mov edi, 0x44f44e | 0x00405a28 mov edx, 0x44d35c | edx = "1 == object->isAcceptable()"; 0x00405a2d mov esi, 0x1f8 | esi = 0x1f8; 0x00405a32 xor eax, eax | eax = 0; 0x00405a34 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a39 mov eax, dword [rip + 0x262f49] | eax = (anonymous namespace)::testStatus; 0x00405a3f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405a42 ja 0x405a4c | 0x00405a44 inc eax | eax++; 0x00405a46 mov dword [rip + 0x262f3c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405a4c mov al, byte [r15] | al = *(r15); | } 0x00405a4f cmp al, 1 | | if (al == 1) { 0x00405a51 jne 0x405aa9 | 0x00405a53 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x00405a58 jne 0x405aa9 | goto label_37; | } 0x00405a5a mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405a5e mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405a62 test ecx, ecx | | if (ecx != 0) { 0x00405a64 je 0x405a7c | 0x00405a66 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405a69 xor edx, edx | edx = 0; 0x00405a6b div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405a6d xor esi, esi | esi = 0; 0x00405a6f cmp edx, ecx | 0x00405a71 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405a75 imul eax, ecx | eax *= ecx; 0x00405a78 add eax, edx | eax += edx; 0x00405a7a sub eax, esi | eax -= esi; | } 0x00405a7c test al, 3 | | if ((al & 3) != 0) { 0x00405a7e jne 0x405aa9 | goto label_37; | } 0x00405a80 mov edi, 0x44f44e | 0x00405a85 mov edx, 0x44d378 | edx = "0 == object->isDone()"; 0x00405a8a mov esi, 0x1f9 | esi = 0x1f9; 0x00405a8f xor eax, eax | eax = 0; 0x00405a91 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a96 mov eax, dword [rip + 0x262eec] | eax = (anonymous namespace)::testStatus; 0x00405a9c cmp eax, 0x64 | | if (eax > 0x64) { 0x00405a9f ja 0x405aa9 | goto label_37; | } 0x00405aa1 inc eax | eax++; 0x00405aa3 mov dword [rip + 0x262edf], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_37: 0x00405aa9 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405aad jne 0x405ad8 | 0x00405aaf mov edi, 0x44f44e | 0x00405ab4 mov edx, 0x44d38e | edx = "0 == object->isError()"; 0x00405ab9 mov esi, 0x1fa | esi = 0x1fa; 0x00405abe xor eax, eax | eax = 0; 0x00405ac0 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405ac5 mov eax, dword [rip + 0x262ebd] | eax = (anonymous namespace)::testStatus; 0x00405acb cmp eax, 0x64 | | if (eax > 0x64) { 0x00405ace ja 0x405ad8 | goto label_38; | } 0x00405ad0 inc eax | eax++; 0x00405ad2 mov dword [rip + 0x262eb0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_38: 0x00405ad8 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405add jne 0x405e3a | goto label_1; | } 0x00405ae3 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x00405ae7 je 0x405f34 | goto label_39; | } | label_5: 0x00405aed mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405af2 mov edx, 0x44d449 | edx = "0 != object->outputLength()"; 0x00405af7 mov esi, 0x1fc | esi = 0x1fc; 0x00405afc jmp 0x405e20 | goto label_12; 0x00405b01 lea rsi, [rsp + 0x18] | 0x00405b06 lea rdx, [rsp + 0x10] | 0x00405b0b mov rdi, r15 | 0x00405b0e mov ecx, 0xffffffff | 0x00405b13 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405b18 test eax, eax | | if (eax != 0) { 0x00405b1a je 0x405b45 | 0x00405b1c mov edi, 0x44f44e | 0x00405b21 mov edx, 0x44d471 | edx = "0 == object->endConvert(b, &numOut)"; 0x00405b26 mov esi, 0x1ff | esi = 0x1ff; 0x00405b2b xor eax, eax | eax = 0; 0x00405b2d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405b32 mov eax, dword [rip + 0x262e50] | eax = (anonymous namespace)::testStatus; 0x00405b38 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405b3b ja 0x405b45 | goto label_40; | } 0x00405b3d inc eax | eax++; 0x00405b3f mov dword [rip + 0x262e43], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_40: 0x00405b45 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405b4a je 0x405b75 | 0x00405b4c mov edi, 0x44f44e | 0x00405b51 mov edx, 0x44d495 | edx = "0 == numOut"; 0x00405b56 mov esi, 0x200 | esi = 0x200; 0x00405b5b xor eax, eax | eax = 0; 0x00405b5d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405b62 mov eax, dword [rip + 0x262e20] | eax = (anonymous namespace)::testStatus; 0x00405b68 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405b6b ja 0x405b75 | goto label_41; | } 0x00405b6d inc eax | eax++; 0x00405b6f mov dword [rip + 0x262e13], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_41: 0x00405b75 mov al, byte [r15] | al = *(r15); 0x00405b78 cmp al, 0xff | | if (al != 0xff) { 0x00405b7a je 0x405d55 | 0x00405b80 cmp al, 1 | | if (al != 1) { 0x00405b82 je 0x405d85 | 0x00405b88 jmp 0x405db2 | goto label_42; 0x00405b8d lea rsi, [rsp + 0x18] | 0x00405b92 lea rdx, [rsp + 0x10] | 0x00405b97 mov rdi, r15 | 0x00405b9a mov ecx, 0xffffffff | 0x00405b9f call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405ba4 test eax, eax | | if (eax != 0) { 0x00405ba6 je 0x405bd1 | 0x00405ba8 mov edi, 0x44f44e | 0x00405bad mov edx, 0x44d471 | edx = "0 == object->endConvert(b, &numOut)"; 0x00405bb2 mov esi, 0x209 | esi = 0x209; 0x00405bb7 xor eax, eax | eax = 0; 0x00405bb9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405bbe mov eax, dword [rip + 0x262dc4] | eax = (anonymous namespace)::testStatus; 0x00405bc4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405bc7 ja 0x405bd1 | goto label_43; | } 0x00405bc9 inc eax | eax++; 0x00405bcb mov dword [rip + 0x262db7], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_43: 0x00405bd1 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405bd6 je 0x405c01 | 0x00405bd8 mov edi, 0x44f44e | 0x00405bdd mov edx, 0x44d495 | edx = "0 == numOut"; 0x00405be2 mov esi, 0x20a | esi = 0x20a; 0x00405be7 xor eax, eax | eax = 0; 0x00405be9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405bee mov eax, dword [rip + 0x262d94] | eax = (anonymous namespace)::testStatus; 0x00405bf4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405bf7 ja 0x405c01 | goto label_44; | } 0x00405bf9 inc eax | eax++; 0x00405bfb mov dword [rip + 0x262d87], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_44: 0x00405c01 lea rsi, [rsp + 0x18] | 0x00405c06 lea rdx, [rsp + 0x10] | 0x00405c0b mov rdi, r15 | 0x00405c0e mov ecx, 0xffffffff | 0x00405c13 call 0x421790 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405c18 cmp eax, 0xffffffff | | if (eax != 0xffffffff) { 0x00405c1b je 0x405c46 | 0x00405c1d mov edi, 0x44f44e | 0x00405c22 mov edx, 0x44d4b7 | edx = "-1 == object->endConvert(b, &numOut)"; 0x00405c27 mov esi, 0x20c | esi = 0x20c; 0x00405c2c xor eax, eax | eax = 0; 0x00405c2e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c33 mov eax, dword [rip + 0x262d4f] | eax = (anonymous namespace)::testStatus; 0x00405c39 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405c3c ja 0x405c46 | goto label_45; | } 0x00405c3e inc eax | eax++; 0x00405c40 mov dword [rip + 0x262d42], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_45: 0x00405c46 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405c4b je 0x405c76 | 0x00405c4d mov edi, 0x44f44e | 0x00405c52 mov edx, 0x44d495 | edx = "0 == numOut"; 0x00405c57 mov esi, 0x20d | esi = 0x20d; 0x00405c5c xor eax, eax | eax = 0; 0x00405c5e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c63 mov eax, dword [rip + 0x262d1f] | eax = (anonymous namespace)::testStatus; 0x00405c69 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405c6c ja 0x405c76 | goto label_46; | } 0x00405c6e inc eax | eax++; 0x00405c70 mov dword [rip + 0x262d12], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_46: 0x00405c76 cmp byte [r15], 0xff | | if (*(r15) != 0xff) { 0x00405c7a je 0x405d36 | 0x00405c80 mov edi, 0x44f44e | 0x00405c85 mov edx, 0x44d4dc | edx = "0 == object->isAcceptable()"; 0x00405c8a mov esi, 0x20f | esi = 0x20f; 0x00405c8f xor eax, eax | eax = 0; 0x00405c91 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c96 mov eax, dword [rip + 0x262cec] | eax = (anonymous namespace)::testStatus; 0x00405c9c cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405c9f ja 0x405ca9 | 0x00405ca1 inc eax | eax++; 0x00405ca3 mov dword [rip + 0x262cdf], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405ca9 mov al, byte [r15] | al = *(r15); 0x00405cac cmp al, 1 | | if (al == 1) { 0x00405cae jne 0x405d09 | 0x00405cb0 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) == 0) { 0x00405cb5 jne 0x405d06 | 0x00405cb7 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405cbb mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405cbf test ecx, ecx | | if (ecx != 0) { 0x00405cc1 je 0x405cd9 | 0x00405cc3 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405cc6 xor edx, edx | edx = 0; 0x00405cc8 div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405cca xor esi, esi | esi = 0; 0x00405ccc cmp edx, ecx | 0x00405cce setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405cd2 imul eax, ecx | eax *= ecx; 0x00405cd5 add eax, edx | eax += edx; 0x00405cd7 sub eax, esi | eax -= esi; | } 0x00405cd9 test al, 3 | | if ((al & 3) != 0) { 0x00405cdb jne 0x405d06 | goto label_47; | } 0x00405cdd mov edi, 0x44f44e | 0x00405ce2 mov edx, 0x44d378 | edx = "0 == object->isDone()"; 0x00405ce7 mov esi, 0x210 | esi = 0x210; 0x00405cec xor eax, eax | eax = 0; 0x00405cee call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405cf3 mov eax, dword [rip + 0x262c8f] | eax = (anonymous namespace)::testStatus; 0x00405cf9 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405cfc ja 0x405d06 | goto label_47; | } 0x00405cfe inc eax | eax++; 0x00405d00 mov dword [rip + 0x262c82], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_47: 0x00405d06 mov al, byte [r15] | al = *(r15); | } 0x00405d09 cmp al, 0xff | | if (al == 0xff) { 0x00405d0b je 0x405d36 | goto label_48; | } 0x00405d0d mov edi, 0x44f44e | 0x00405d12 mov edx, 0x44d4f8 | edx = "1 == object->isError()"; 0x00405d17 mov esi, 0x211 | esi = 0x211; 0x00405d1c xor eax, eax | eax = 0; 0x00405d1e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405d23 mov eax, dword [rip + 0x262c5f] | eax = (anonymous namespace)::testStatus; 0x00405d29 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405d2c ja 0x405d36 | goto label_48; | } 0x00405d2e inc eax | eax++; 0x00405d30 mov dword [rip + 0x262c52], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_48: 0x00405d36 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x00405d3b je 0x405e47 | goto label_49; | } | label_0: 0x00405d41 mov edi, 0x44f44e | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405d46 mov edx, 0x44d3c3 | edx = "0 == object->outputLength()"; 0x00405d4b mov esi, 0x213 | esi = 0x213; 0x00405d50 jmp 0x405e20 | | } else { 0x00405d55 mov edi, 0x44f44e | 0x00405d5a mov edx, 0x44d35c | edx = "1 == object->isAcceptable()"; 0x00405d5f mov esi, 0x202 | esi = 0x202; 0x00405d64 xor eax, eax | eax = 0; 0x00405d66 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405d6b mov eax, dword [rip + 0x262c17] | eax = (anonymous namespace)::testStatus; 0x00405d71 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405d74 ja 0x405d7e | 0x00405d76 inc eax | eax++; 0x00405d78 mov dword [rip + 0x262c0a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405d7e mov al, byte [r15] | al = *(r15); 0x00405d81 cmp al, 1 | | if (al != 1) { 0x00405d83 jne 0x405db2 | goto label_42; | } | } 0x00405d85 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) == 0) { 0x00405d8a jne 0x405db2 | 0x00405d8c mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405d90 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405d94 test ecx, ecx | | if (ecx != 0) { 0x00405d96 je 0x405dae | 0x00405d98 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405d9b xor edx, edx | edx = 0; 0x00405d9d div esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405d9f xor esi, esi | esi = 0; 0x00405da1 cmp edx, ecx | 0x00405da3 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405da7 imul eax, ecx | eax *= ecx; 0x00405daa add eax, edx | eax += edx; 0x00405dac sub eax, esi | eax -= esi; | } 0x00405dae test al, 3 | | if ((al & 3) == 0) { 0x00405db0 je 0x405ddb | goto label_50; | } | } | label_42: 0x00405db2 mov edi, 0x44f44e | 0x00405db7 mov edx, 0x44d4a1 | edx = "1 == object->isDone()"; 0x00405dbc mov esi, 0x203 | esi = 0x203; 0x00405dc1 xor eax, eax | eax = 0; 0x00405dc3 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405dc8 mov eax, dword [rip + 0x262bba] | eax = (anonymous namespace)::testStatus; 0x00405dce cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405dd1 ja 0x405ddb | 0x00405dd3 inc eax | eax++; 0x00405dd5 mov dword [rip + 0x262bad], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_50: 0x00405ddb cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405ddf jne 0x405e0a | 0x00405de1 mov edi, 0x44f44e | 0x00405de6 mov edx, 0x44d38e | edx = "0 == object->isError()"; 0x00405deb mov esi, 0x204 | esi = 0x204; 0x00405df0 xor eax, eax | eax = 0; 0x00405df2 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405df7 mov eax, dword [rip + 0x262b8b] | eax = (anonymous namespace)::testStatus; 0x00405dfd cmp eax, 0x64 | | if (eax > 0x64) { 0x00405e00 ja 0x405e0a | goto label_51; | } 0x00405e02 inc eax | eax++; 0x00405e04 mov dword [rip + 0x262b7e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_51: 0x00405e0a cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x00405e0f je 0x405e83 | goto label_52; | } | label_2: 0x00405e11 mov edi, 0x44f44e | 0x00405e16 mov edx, 0x44d3c3 | edx = "0 == object->outputLength()"; 0x00405e1b mov esi, 0x206 | esi = 0x206; | } | } | label_12: 0x00405e20 xor eax, eax | eax = 0; 0x00405e22 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e27 mov eax, dword [rip + 0x262b5b] | eax = (anonymous namespace)::testStatus; 0x00405e2d cmp eax, 0x64 | | if (eax > 0x64) { 0x00405e30 ja 0x405e3a | goto label_1; | } 0x00405e32 inc eax | eax++; 0x00405e34 mov dword [rip + 0x262b4e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | do { | label_1: 0x00405e3a add rsp, 0x20 | 0x00405e3e pop rbx | 0x00405e3f pop r12 | 0x00405e41 pop r14 | 0x00405e43 pop r15 | 0x00405e45 pop rbp | 0x00405e46 ret | return rax; | label_49: 0x00405e47 cmp byte [r15], 0 | 0x00405e4b jne 0x405e3a | | } while (*(r15) != 0); 0x00405e4d mov edi, 0x44f44e | 0x00405e52 mov edx, 0x44d42b | edx = "0 == object->isInitialState()"; 0x00405e57 mov esi, 0x212 | esi = 0x212; 0x00405e5c xor eax, eax | eax = 0; 0x00405e5e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e63 mov eax, dword [rip + 0x262b1f] | eax = (anonymous namespace)::testStatus; 0x00405e69 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405e6c ja 0x405e76 | 0x00405e6e inc eax | eax++; 0x00405e70 mov dword [rip + 0x262b12], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405e76 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405e7b jne 0x405d41 | goto label_0; | } 0x00405e81 jmp 0x405e3a | goto label_1; | label_52: 0x00405e83 cmp byte [r15], 0 | | if (*(r15) != 0) { 0x00405e87 jne 0x405e3a | goto label_1; | } 0x00405e89 mov edi, 0x44f44e | 0x00405e8e mov edx, 0x44d42b | edx = "0 == object->isInitialState()"; 0x00405e93 mov esi, 0x205 | esi = 0x205; 0x00405e98 xor eax, eax | eax = 0; 0x00405e9a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e9f mov eax, dword [rip + 0x262ae3] | eax = (anonymous namespace)::testStatus; 0x00405ea5 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405ea8 ja 0x405eb2 | 0x00405eaa inc eax | eax++; 0x00405eac mov dword [rip + 0x262ad6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405eb2 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405eb7 jne 0x405e11 | goto label_2; | } 0x00405ebd jmp 0x405e3a | goto label_1; | label_18: 0x00405ec2 mov edi, 0x44f44e | 0x00405ec7 mov edx, 0x44d42b | edx = "0 == object->isInitialState()"; 0x00405ecc mov esi, 0x1de | esi = 0x1de; 0x00405ed1 xor eax, eax | eax = 0; 0x00405ed3 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405ed8 mov eax, dword [rip + 0x262aaa] | eax = (anonymous namespace)::testStatus; 0x00405ede cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405ee1 ja 0x405eeb | 0x00405ee3 inc eax | eax++; 0x00405ee5 mov dword [rip + 0x262a9d], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405eeb cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405ef0 jne 0x405e3a | goto label_1; | } 0x00405ef6 jmp 0x4055a4 | goto label_3; | label_27: 0x00405efb mov edi, 0x44f44e | 0x00405f00 mov edx, 0x44d42b | edx = "0 == object->isInitialState()"; 0x00405f05 mov esi, 0x1eb | esi = 0x1eb; 0x00405f0a xor eax, eax | eax = 0; 0x00405f0c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405f11 mov eax, dword [rip + 0x262a71] | eax = (anonymous namespace)::testStatus; 0x00405f17 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405f1a ja 0x405f24 | 0x00405f1c inc eax | eax++; 0x00405f1e mov dword [rip + 0x262a64], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405f24 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405f29 jne 0x405e3a | goto label_1; | } 0x00405f2f jmp 0x4057ef | goto label_4; | label_39: 0x00405f34 mov edi, 0x44f44e | 0x00405f39 mov edx, 0x44d42b | edx = "0 == object->isInitialState()"; 0x00405f3e mov esi, 0x1fb | esi = 0x1fb; 0x00405f43 xor eax, eax | eax = 0; 0x00405f45 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405f4a mov eax, dword [rip + 0x262a38] | eax = (anonymous namespace)::testStatus; 0x00405f50 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405f53 ja 0x405f5d | 0x00405f55 inc eax | eax++; 0x00405f57 mov dword [rip + 0x262a2b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405f5d cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405f62 jne 0x405e3a | goto label_1; | } 0x00405f68 jmp 0x405aed | goto label_5; | }