; assembly | /* r2dec pseudo code output */ | /* bdlde_base64encoder.t/none @ 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, 0x44f523 | 0x0040514c mov edx, 0x44d36d | 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-none/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, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405180 mov edx, 0x44d37f | edx = "state < NUM_STATES"; 0x00405185 jmp 0x405191 | | } else { 0x00405187 mov edi, 0x44f523 | 0x0040518c mov edx, 0x44d374 | 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-none/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, 0x44d392 | 0x004051cb mov edx, 0x3d | 0x004051d0 call 0x423700 | 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, 0x44d3d0 | 0x00405230 mov edx, 0x3b | 0x00405235 mov rdi, rbx | 0x00405238 call 0x423700 | 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, 0x44f523 | 0x004052a5 mov edx, 0x44d4e0 | edx = 0x44d4e0; 0x004052aa mov esi, 0x1c4 | esi = 0x1c4; 0x004052af xor eax, eax | eax = 0; 0x004052b1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/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 0x40540b | 0x004052e8 lea r14, [rsp + 0x10] | r14 = rsp + 0x10; 0x004052ed mov eax, r12d | eax = r12d; | /* switch table (6 cases) at 0x449c40 */ 0x004052f0 jmp qword [rax*8 + 0x449c40] | 0x004052f7 mov al, byte [r15] | al = *(r15); 0x004052fa cmp al, 0xff | | if (al == 0xff) { 0x004052fc jne 0x40532a | 0x004052fe mov edi, 0x44f523 | 0x00405303 mov edx, 0x44d40c | 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-none/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 0x405383 | 0x0040532e cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x00405333 jne 0x405383 | 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 0x405356 | 0x00405341 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405344 cdq | edx:eax = (int64_t) eax; 0x00405345 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405347 xor esi, esi | esi = 0; 0x00405349 cmp edx, ecx | 0x0040534b setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040534f imul eax, ecx | eax *= ecx; 0x00405352 add eax, edx | eax += edx; 0x00405354 sub eax, esi | eax -= esi; | } 0x00405356 test al, 3 | | if ((al & 3) != 0) { 0x00405358 jne 0x405383 | goto label_10; | } 0x0040535a mov edi, 0x44f523 | 0x0040535f mov edx, 0x44d428 | edx = "0 == object->isDone()"; 0x00405364 mov esi, 0x1d2 | esi = 0x1d2; 0x00405369 xor eax, eax | eax = 0; 0x0040536b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405370 mov eax, dword [rip + 0x263612] | eax = (anonymous namespace)::testStatus; 0x00405376 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405379 ja 0x405383 | goto label_10; | } 0x0040537b inc eax | eax++; 0x0040537d mov dword [rip + 0x263605], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x00405383 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405387 jne 0x4053b2 | 0x00405389 mov edi, 0x44f523 | 0x0040538e mov edx, 0x44d43e | edx = "0 == object->isError()"; 0x00405393 mov esi, 0x1d3 | esi = 0x1d3; 0x00405398 xor eax, eax | eax = 0; 0x0040539a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040539f mov eax, dword [rip + 0x2635e3] | eax = (anonymous namespace)::testStatus; 0x004053a5 cmp eax, 0x64 | | if (eax > 0x64) { 0x004053a8 ja 0x4053b2 | goto label_11; | } 0x004053aa inc eax | eax++; 0x004053ac mov dword [rip + 0x2635d6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_11: 0x004053b2 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x004053b7 jne 0x4053c3 | 0x004053b9 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x004053bd je 0x405e34 | goto label_1; | } | } 0x004053c3 mov edi, 0x44f523 | 0x004053c8 mov edx, 0x44d455 | edx = "1 == object->isInitialState()"; 0x004053cd mov esi, 0x1d4 | esi = 0x1d4; 0x004053d2 xor eax, eax | eax = 0; 0x004053d4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004053d9 mov eax, dword [rip + 0x2635a9] | eax = (anonymous namespace)::testStatus; 0x004053df cmp eax, 0x64 | | if (eax <= 0x64) { 0x004053e2 ja 0x4053ec | 0x004053e4 inc eax | eax++; 0x004053e6 mov dword [rip + 0x26359c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x004053ec cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x004053f1 je 0x405e34 | goto label_1; | } 0x004053f7 mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004053fc mov edx, 0x44d473 | edx = "0 == object->outputLength()"; 0x00405401 mov esi, 0x1d5 | esi = 0x1d5; 0x00405406 jmp 0x405e1a | | } else { 0x0040540b mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405410 mov edx, 0x44d5bf | edx = "\"Unknown State\" && 0"; 0x00405415 mov esi, 0x216 | esi = 0x216; 0x0040541a jmp 0x405e1a | goto label_12; 0x0040541f mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405426 lea rsi, [rsp + 0x18] | 0x0040542b lea rdx, [rsp + 0x10] | 0x00405430 lea rcx, [rsp + 0x14] | 0x00405435 lea r8, [rsp + 0xf] | 0x0040543a mov rdi, r15 | 0x0040543d mov r9, r14 | 0x00405440 call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x00405445 test eax, eax | | if (eax != 0) { 0x00405447 je 0x405472 | 0x00405449 mov edi, 0x44f523 | 0x0040544e mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x00405453 mov esi, 0x1d8 | esi = 0x1d8; 0x00405458 xor eax, eax | eax = 0; 0x0040545a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040545f mov eax, dword [rip + 0x263523] | eax = (anonymous namespace)::testStatus; 0x00405465 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405468 ja 0x405472 | goto label_13; | } 0x0040546a inc eax | eax++; 0x0040546c mov dword [rip + 0x263516], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_13: 0x00405472 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x00405477 je 0x4054a2 | 0x00405479 mov edi, 0x44f523 | 0x0040547e mov edx, 0x44d4c4 | edx = "1 == numOut"; 0x00405483 mov esi, 0x1d9 | esi = 0x1d9; 0x00405488 xor eax, eax | eax = 0; 0x0040548a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040548f mov eax, dword [rip + 0x2634f3] | eax = (anonymous namespace)::testStatus; 0x00405495 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405498 ja 0x4054a2 | goto label_14; | } 0x0040549a inc eax | eax++; 0x0040549c mov dword [rip + 0x2634e6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_14: 0x004054a2 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004054a7 je 0x4054d2 | 0x004054a9 mov edi, 0x44f523 | 0x004054ae mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x004054b3 mov esi, 0x1d9 | esi = 0x1d9; 0x004054b8 xor eax, eax | eax = 0; 0x004054ba call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004054bf mov eax, dword [rip + 0x2634c3] | eax = (anonymous namespace)::testStatus; 0x004054c5 cmp eax, 0x64 | | if (eax > 0x64) { 0x004054c8 ja 0x4054d2 | goto label_15; | } 0x004054ca inc eax | eax++; 0x004054cc mov dword [rip + 0x2634b6], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_15: 0x004054d2 mov al, byte [r15] | al = *(r15); 0x004054d5 cmp al, 0xff | | if (al == 0xff) { 0x004054d7 jne 0x405505 | 0x004054d9 mov edi, 0x44f523 | 0x004054de mov edx, 0x44d40c | edx = "1 == object->isAcceptable()"; 0x004054e3 mov esi, 0x1db | esi = 0x1db; 0x004054e8 xor eax, eax | eax = 0; 0x004054ea call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004054ef mov eax, dword [rip + 0x263493] | eax = (anonymous namespace)::testStatus; 0x004054f5 cmp eax, 0x64 | | if (eax <= 0x64) { 0x004054f8 ja 0x405502 | 0x004054fa inc eax | eax++; 0x004054fc mov dword [rip + 0x263486], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405502 mov al, byte [r15] | al = *(r15); | } 0x00405505 cmp al, 1 | | if (al == 1) { 0x00405507 jne 0x40555e | 0x00405509 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x0040550e jne 0x40555e | goto label_16; | } 0x00405510 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405514 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405518 test ecx, ecx | | if (ecx != 0) { 0x0040551a je 0x405531 | 0x0040551c lea esi, [rcx + 2] | esi = rcx + 2; 0x0040551f cdq | edx:eax = (int64_t) eax; 0x00405520 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405522 xor esi, esi | esi = 0; 0x00405524 cmp edx, ecx | 0x00405526 setg sil | sil = (edx > ecx) ? 1 : 0; 0x0040552a imul eax, ecx | eax *= ecx; 0x0040552d add eax, edx | eax += edx; 0x0040552f sub eax, esi | eax -= esi; | } 0x00405531 test al, 3 | | if ((al & 3) != 0) { 0x00405533 jne 0x40555e | goto label_16; | } 0x00405535 mov edi, 0x44f523 | 0x0040553a mov edx, 0x44d428 | edx = "0 == object->isDone()"; 0x0040553f mov esi, 0x1dc | esi = 0x1dc; 0x00405544 xor eax, eax | eax = 0; 0x00405546 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040554b mov eax, dword [rip + 0x263437] | eax = (anonymous namespace)::testStatus; 0x00405551 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405554 ja 0x40555e | goto label_16; | } 0x00405556 inc eax | eax++; 0x00405558 mov dword [rip + 0x26342a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_16: 0x0040555e cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405562 jne 0x40558d | 0x00405564 mov edi, 0x44f523 | 0x00405569 mov edx, 0x44d43e | edx = "0 == object->isError()"; 0x0040556e mov esi, 0x1dd | esi = 0x1dd; 0x00405573 xor eax, eax | eax = 0; 0x00405575 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x0040557a mov eax, dword [rip + 0x263408] | eax = (anonymous namespace)::testStatus; 0x00405580 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405583 ja 0x40558d | goto label_17; | } 0x00405585 inc eax | eax++; 0x00405587 mov dword [rip + 0x2633fb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_17: 0x0040558d cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405592 jne 0x405e34 | goto label_1; | } 0x00405598 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x0040559c je 0x405ebc | goto label_18; | } | label_3: 0x004055a2 mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004055a7 mov edx, 0x44d4f9 | edx = "0 != object->outputLength()"; 0x004055ac mov esi, 0x1df | esi = 0x1df; 0x004055b1 jmp 0x405e1a | goto label_12; 0x004055b6 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004055bd lea rsi, [rsp + 0x18] | 0x004055c2 lea rdx, [rsp + 0x10] | 0x004055c7 lea rcx, [rsp + 0x14] | 0x004055cc lea r8, [rsp + 0xf] | 0x004055d1 mov rdi, r15 | 0x004055d4 mov r9, r14 | 0x004055d7 call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x004055dc test eax, eax | | if (eax != 0) { 0x004055de je 0x405609 | 0x004055e0 mov edi, 0x44f523 | 0x004055e5 mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x004055ea mov esi, 0x1e2 | esi = 0x1e2; 0x004055ef xor eax, eax | eax = 0; 0x004055f1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004055f6 mov eax, dword [rip + 0x26338c] | eax = (anonymous namespace)::testStatus; 0x004055fc cmp eax, 0x64 | | if (eax > 0x64) { 0x004055ff ja 0x405609 | goto label_19; | } 0x00405601 inc eax | eax++; 0x00405603 mov dword [rip + 0x26337f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_19: 0x00405609 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x0040560e je 0x405639 | 0x00405610 mov edi, 0x44f523 | 0x00405615 mov edx, 0x44d4c4 | edx = "1 == numOut"; 0x0040561a mov esi, 0x1e3 | esi = 0x1e3; 0x0040561f xor eax, eax | eax = 0; 0x00405621 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405626 mov eax, dword [rip + 0x26335c] | eax = (anonymous namespace)::testStatus; 0x0040562c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040562f ja 0x405639 | goto label_20; | } 0x00405631 inc eax | eax++; 0x00405633 mov dword [rip + 0x26334f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_20: 0x00405639 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x0040563e je 0x405669 | 0x00405640 mov edi, 0x44f523 | 0x00405645 mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x0040564a mov esi, 0x1e3 | esi = 0x1e3; 0x0040564f xor eax, eax | eax = 0; 0x00405651 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405656 mov eax, dword [rip + 0x26332c] | eax = (anonymous namespace)::testStatus; 0x0040565c cmp eax, 0x64 | | if (eax > 0x64) { 0x0040565f ja 0x405669 | goto label_21; | } 0x00405661 inc eax | eax++; 0x00405663 mov dword [rip + 0x26331f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_21: 0x00405669 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405670 lea rsi, [rsp + 0x18] | 0x00405675 lea rdx, [rsp + 0x10] | 0x0040567a lea rcx, [rsp + 0x14] | 0x0040567f lea r8, [rsp + 0xf] | 0x00405684 mov rdi, r15 | 0x00405687 mov r9, r14 | 0x0040568a call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x0040568f test eax, eax | | if (eax != 0) { 0x00405691 je 0x4056bc | 0x00405693 mov edi, 0x44f523 | 0x00405698 mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x0040569d mov esi, 0x1e5 | esi = 0x1e5; 0x004056a2 xor eax, eax | eax = 0; 0x004056a4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004056a9 mov eax, dword [rip + 0x2632d9] | eax = (anonymous namespace)::testStatus; 0x004056af cmp eax, 0x64 | | if (eax > 0x64) { 0x004056b2 ja 0x4056bc | goto label_22; | } 0x004056b4 inc eax | eax++; 0x004056b6 mov dword [rip + 0x2632cc], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_22: 0x004056bc cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x004056c1 je 0x4056ec | 0x004056c3 mov edi, 0x44f523 | 0x004056c8 mov edx, 0x44d4c4 | edx = "1 == numOut"; 0x004056cd mov esi, 0x1e6 | esi = 0x1e6; 0x004056d2 xor eax, eax | eax = 0; 0x004056d4 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004056d9 mov eax, dword [rip + 0x2632a9] | eax = (anonymous namespace)::testStatus; 0x004056df cmp eax, 0x64 | | if (eax > 0x64) { 0x004056e2 ja 0x4056ec | goto label_23; | } 0x004056e4 inc eax | eax++; 0x004056e6 mov dword [rip + 0x26329c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_23: 0x004056ec cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004056f1 je 0x40571c | 0x004056f3 mov edi, 0x44f523 | 0x004056f8 mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x004056fd mov esi, 0x1e6 | esi = 0x1e6; 0x00405702 xor eax, eax | eax = 0; 0x00405704 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405709 mov eax, dword [rip + 0x263279] | eax = (anonymous namespace)::testStatus; 0x0040570f cmp eax, 0x64 | | if (eax > 0x64) { 0x00405712 ja 0x40571c | goto label_24; | } 0x00405714 inc eax | eax++; 0x00405716 mov dword [rip + 0x26326c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_24: 0x0040571c mov al, byte [r15] | al = *(r15); 0x0040571f cmp al, 0xff | | if (al == 0xff) { 0x00405721 jne 0x40574f | 0x00405723 mov edi, 0x44f523 | 0x00405728 mov edx, 0x44d40c | edx = "1 == object->isAcceptable()"; 0x0040572d mov esi, 0x1e8 | esi = 0x1e8; 0x00405732 xor eax, eax | eax = 0; 0x00405734 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405739 mov eax, dword [rip + 0x263249] | eax = (anonymous namespace)::testStatus; 0x0040573f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405742 ja 0x40574c | 0x00405744 inc eax | eax++; 0x00405746 mov dword [rip + 0x26323c], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x0040574c mov al, byte [r15] | al = *(r15); | } 0x0040574f cmp al, 1 | | if (al == 1) { 0x00405751 jne 0x4057a8 | 0x00405753 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x00405758 jne 0x4057a8 | goto label_25; | } 0x0040575a mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x0040575e mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405762 test ecx, ecx | | if (ecx != 0) { 0x00405764 je 0x40577b | 0x00405766 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405769 cdq | edx:eax = (int64_t) eax; 0x0040576a idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x0040576c xor esi, esi | esi = 0; 0x0040576e cmp edx, ecx | 0x00405770 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405774 imul eax, ecx | eax *= ecx; 0x00405777 add eax, edx | eax += edx; 0x00405779 sub eax, esi | eax -= esi; | } 0x0040577b test al, 3 | | if ((al & 3) != 0) { 0x0040577d jne 0x4057a8 | goto label_25; | } 0x0040577f mov edi, 0x44f523 | 0x00405784 mov edx, 0x44d428 | edx = "0 == object->isDone()"; 0x00405789 mov esi, 0x1e9 | esi = 0x1e9; 0x0040578e xor eax, eax | eax = 0; 0x00405790 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405795 mov eax, dword [rip + 0x2631ed] | eax = (anonymous namespace)::testStatus; 0x0040579b cmp eax, 0x64 | | if (eax > 0x64) { 0x0040579e ja 0x4057a8 | goto label_25; | } 0x004057a0 inc eax | eax++; 0x004057a2 mov dword [rip + 0x2631e0], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_25: 0x004057a8 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x004057ac jne 0x4057d7 | 0x004057ae mov edi, 0x44f523 | 0x004057b3 mov edx, 0x44d43e | edx = "0 == object->isError()"; 0x004057b8 mov esi, 0x1ea | esi = 0x1ea; 0x004057bd xor eax, eax | eax = 0; 0x004057bf call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004057c4 mov eax, dword [rip + 0x2631be] | eax = (anonymous namespace)::testStatus; 0x004057ca cmp eax, 0x64 | | if (eax > 0x64) { 0x004057cd ja 0x4057d7 | goto label_26; | } 0x004057cf inc eax | eax++; 0x004057d1 mov dword [rip + 0x2631b1], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_26: 0x004057d7 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x004057dc jne 0x405e34 | goto label_1; | } 0x004057e2 cmp byte [r15], 0 | | if (*(r15) == 0) { 0x004057e6 je 0x405ef5 | goto label_27; | } | label_4: 0x004057ec mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x004057f1 mov edx, 0x44d4f9 | edx = "0 != object->outputLength()"; 0x004057f6 mov esi, 0x1ec | esi = 0x1ec; 0x004057fb jmp 0x405e1a | goto label_12; 0x00405800 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x00405807 lea rsi, [rsp + 0x18] | 0x0040580c lea rdx, [rsp + 0x10] | 0x00405811 lea rcx, [rsp + 0x14] | 0x00405816 lea r8, [rsp + 0xf] | 0x0040581b mov rdi, r15 | 0x0040581e mov r9, r14 | 0x00405821 call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x00405826 test eax, eax | | if (eax != 0) { 0x00405828 je 0x405853 | 0x0040582a mov edi, 0x44f523 | 0x0040582f mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x00405834 mov esi, 0x1ef | esi = 0x1ef; 0x00405839 xor eax, eax | eax = 0; 0x0040583b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405840 mov eax, dword [rip + 0x263142] | eax = (anonymous namespace)::testStatus; 0x00405846 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405849 ja 0x405853 | goto label_28; | } 0x0040584b inc eax | eax++; 0x0040584d mov dword [rip + 0x263135], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x00405853 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x00405858 je 0x405883 | 0x0040585a mov edi, 0x44f523 | 0x0040585f mov edx, 0x44d4c4 | edx = "1 == numOut"; 0x00405864 mov esi, 0x1f0 | esi = 0x1f0; 0x00405869 xor eax, eax | eax = 0; 0x0040586b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405870 mov eax, dword [rip + 0x263112] | eax = (anonymous namespace)::testStatus; 0x00405876 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405879 ja 0x405883 | goto label_29; | } 0x0040587b inc eax | eax++; 0x0040587d mov dword [rip + 0x263105], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_29: 0x00405883 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x00405888 je 0x4058b3 | 0x0040588a mov edi, 0x44f523 | 0x0040588f mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x00405894 mov esi, 0x1f0 | esi = 0x1f0; 0x00405899 xor eax, eax | eax = 0; 0x0040589b call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004058a0 mov eax, dword [rip + 0x2630e2] | eax = (anonymous namespace)::testStatus; 0x004058a6 cmp eax, 0x64 | | if (eax > 0x64) { 0x004058a9 ja 0x4058b3 | goto label_30; | } 0x004058ab inc eax | eax++; 0x004058ad mov dword [rip + 0x2630d5], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_30: 0x004058b3 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x004058ba lea rsi, [rsp + 0x18] | 0x004058bf lea rdx, [rsp + 0x10] | 0x004058c4 lea rcx, [rsp + 0x14] | 0x004058c9 lea r8, [rsp + 0xf] | 0x004058ce mov rdi, r15 | 0x004058d1 mov r9, r14 | 0x004058d4 call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x004058d9 test eax, eax | | if (eax != 0) { 0x004058db je 0x405906 | 0x004058dd mov edi, 0x44f523 | 0x004058e2 mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x004058e7 mov esi, 0x1f2 | esi = 0x1f2; 0x004058ec xor eax, eax | eax = 0; 0x004058ee call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004058f3 mov eax, dword [rip + 0x26308f] | eax = (anonymous namespace)::testStatus; 0x004058f9 cmp eax, 0x64 | | if (eax > 0x64) { 0x004058fc ja 0x405906 | goto label_31; | } 0x004058fe inc eax | eax++; 0x00405900 mov dword [rip + 0x263082], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_31: 0x00405906 cmp dword [rsp + 0x10], 1 | | if (*((rsp + 0x10)) != 1) { 0x0040590b je 0x405936 | 0x0040590d mov edi, 0x44f523 | 0x00405912 mov edx, 0x44d4c4 | edx = "1 == numOut"; 0x00405917 mov esi, 0x1f3 | esi = 0x1f3; 0x0040591c xor eax, eax | eax = 0; 0x0040591e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405923 mov eax, dword [rip + 0x26305f] | eax = (anonymous namespace)::testStatus; 0x00405929 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040592c ja 0x405936 | goto label_32; | } 0x0040592e inc eax | eax++; 0x00405930 mov dword [rip + 0x263052], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_32: 0x00405936 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x0040593b je 0x405966 | 0x0040593d mov edi, 0x44f523 | 0x00405942 mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x00405947 mov esi, 0x1f3 | esi = 0x1f3; 0x0040594c xor eax, eax | eax = 0; 0x0040594e call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405953 mov eax, dword [rip + 0x26302f] | eax = (anonymous namespace)::testStatus; 0x00405959 cmp eax, 0x64 | | if (eax > 0x64) { 0x0040595c ja 0x405966 | goto label_33; | } 0x0040595e inc eax | eax++; 0x00405960 mov dword [rip + 0x263022], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x00405966 mov dword [rsp], 0xffffffff | *(rsp) = 0xffffffff; 0x0040596d lea rsi, [rsp + 0x18] | 0x00405972 lea rdx, [rsp + 0x10] | 0x00405977 lea rcx, [rsp + 0x14] | 0x0040597c lea r8, [rsp + 0xf] | 0x00405981 mov rdi, r15 | 0x00405984 mov r9, r14 | 0x00405987 call 0x421570 | eax = intBloombergLP::bdlde::Base64Encoder::convert(char*,int*,int*,char const*,char const*,int) (r15, rsp + 0x18, rsp + 0x10, rsp + 0x14, rsp + 0xf, r14); 0x0040598c test eax, eax | | if (eax != 0) { 0x0040598e je 0x4059b9 | 0x00405990 mov edi, 0x44f523 | 0x00405995 mov edx, 0x44d48f | edx = "0 == object->convert(b, &numOut, &numIn, begin, end)"; 0x0040599a mov esi, 0x1f5 | esi = 0x1f5; 0x0040599f xor eax, eax | eax = 0; 0x004059a1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004059a6 mov eax, dword [rip + 0x262fdc] | eax = (anonymous namespace)::testStatus; 0x004059ac cmp eax, 0x64 | | if (eax > 0x64) { 0x004059af ja 0x4059b9 | goto label_34; | } 0x004059b1 inc eax | eax++; 0x004059b3 mov dword [rip + 0x262fcf], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_34: 0x004059b9 cmp dword [rsp + 0x10], 2 | | if (*((rsp + 0x10)) != 2) { 0x004059be je 0x4059e9 | 0x004059c0 mov edi, 0x44f523 | 0x004059c5 mov edx, 0x44d515 | edx = "2 == numOut"; 0x004059ca mov esi, 0x1f6 | esi = 0x1f6; 0x004059cf xor eax, eax | eax = 0; 0x004059d1 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x004059d6 mov eax, dword [rip + 0x262fac] | eax = (anonymous namespace)::testStatus; 0x004059dc cmp eax, 0x64 | | if (eax > 0x64) { 0x004059df ja 0x4059e9 | goto label_35; | } 0x004059e1 inc eax | eax++; 0x004059e3 mov dword [rip + 0x262f9f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_35: 0x004059e9 cmp dword [rsp + 0x14], 1 | | if (*((rsp + 0x14)) != 1) { 0x004059ee je 0x405a19 | 0x004059f0 mov edi, 0x44f523 | 0x004059f5 mov edx, 0x44d4d0 | edx = "1 == numIn"; 0x004059fa mov esi, 0x1f6 | esi = 0x1f6; 0x004059ff xor eax, eax | eax = 0; 0x00405a01 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a06 mov eax, dword [rip + 0x262f7c] | eax = (anonymous namespace)::testStatus; 0x00405a0c cmp eax, 0x64 | | if (eax > 0x64) { 0x00405a0f ja 0x405a19 | goto label_36; | } 0x00405a11 inc eax | eax++; 0x00405a13 mov dword [rip + 0x262f6f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_36: 0x00405a19 mov al, byte [r15] | al = *(r15); 0x00405a1c cmp al, 0xff | | if (al == 0xff) { 0x00405a1e jne 0x405a4c | 0x00405a20 mov edi, 0x44f523 | 0x00405a25 mov edx, 0x44d40c | edx = "1 == object->isAcceptable()"; 0x00405a2a mov esi, 0x1f8 | esi = 0x1f8; 0x00405a2f xor eax, eax | eax = 0; 0x00405a31 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a36 mov eax, dword [rip + 0x262f4c] | eax = (anonymous namespace)::testStatus; 0x00405a3c cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405a3f ja 0x405a49 | 0x00405a41 inc eax | eax++; 0x00405a43 mov dword [rip + 0x262f3f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405a49 mov al, byte [r15] | al = *(r15); | } 0x00405a4c cmp al, 1 | | if (al == 1) { 0x00405a4e jne 0x405aa5 | 0x00405a50 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) != 0) { 0x00405a55 jne 0x405aa5 | goto label_37; | } 0x00405a57 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405a5b mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405a5f test ecx, ecx | | if (ecx != 0) { 0x00405a61 je 0x405a78 | 0x00405a63 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405a66 cdq | edx:eax = (int64_t) eax; 0x00405a67 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405a69 xor esi, esi | esi = 0; 0x00405a6b cmp edx, ecx | 0x00405a6d setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405a71 imul eax, ecx | eax *= ecx; 0x00405a74 add eax, edx | eax += edx; 0x00405a76 sub eax, esi | eax -= esi; | } 0x00405a78 test al, 3 | | if ((al & 3) != 0) { 0x00405a7a jne 0x405aa5 | goto label_37; | } 0x00405a7c mov edi, 0x44f523 | 0x00405a81 mov edx, 0x44d428 | edx = "0 == object->isDone()"; 0x00405a86 mov esi, 0x1f9 | esi = 0x1f9; 0x00405a8b xor eax, eax | eax = 0; 0x00405a8d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405a92 mov eax, dword [rip + 0x262ef0] | eax = (anonymous namespace)::testStatus; 0x00405a98 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405a9b ja 0x405aa5 | goto label_37; | } 0x00405a9d inc eax | eax++; 0x00405a9f mov dword [rip + 0x262ee3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_37: 0x00405aa5 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405aa9 jne 0x405ad4 | 0x00405aab mov edi, 0x44f523 | 0x00405ab0 mov edx, 0x44d43e | edx = "0 == object->isError()"; 0x00405ab5 mov esi, 0x1fa | esi = 0x1fa; 0x00405aba xor eax, eax | eax = 0; 0x00405abc call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405ac1 mov eax, dword [rip + 0x262ec1] | eax = (anonymous namespace)::testStatus; 0x00405ac7 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405aca ja 0x405ad4 | goto label_38; | } 0x00405acc inc eax | eax++; 0x00405ace mov dword [rip + 0x262eb4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_38: 0x00405ad4 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405ad9 jne 0x405e34 | goto label_1; | } 0x00405adf cmp byte [r15], 0 | | if (*(r15) == 0) { 0x00405ae3 je 0x405f2e | goto label_39; | } | label_5: 0x00405ae9 mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405aee mov edx, 0x44d4f9 | edx = "0 != object->outputLength()"; 0x00405af3 mov esi, 0x1fc | esi = 0x1fc; 0x00405af8 jmp 0x405e1a | goto label_12; 0x00405afd lea rsi, [rsp + 0x18] | 0x00405b02 lea rdx, [rsp + 0x10] | 0x00405b07 mov rdi, r15 | 0x00405b0a mov ecx, 0xffffffff | 0x00405b0f call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405b14 test eax, eax | | if (eax != 0) { 0x00405b16 je 0x405b41 | 0x00405b18 mov edi, 0x44f523 | 0x00405b1d mov edx, 0x44d521 | edx = "0 == object->endConvert(b, &numOut)"; 0x00405b22 mov esi, 0x1ff | esi = 0x1ff; 0x00405b27 xor eax, eax | eax = 0; 0x00405b29 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405b2e mov eax, dword [rip + 0x262e54] | eax = (anonymous namespace)::testStatus; 0x00405b34 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405b37 ja 0x405b41 | goto label_40; | } 0x00405b39 inc eax | eax++; 0x00405b3b mov dword [rip + 0x262e47], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_40: 0x00405b41 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405b46 je 0x405b71 | 0x00405b48 mov edi, 0x44f523 | 0x00405b4d mov edx, 0x44d545 | edx = "0 == numOut"; 0x00405b52 mov esi, 0x200 | esi = 0x200; 0x00405b57 xor eax, eax | eax = 0; 0x00405b59 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405b5e mov eax, dword [rip + 0x262e24] | eax = (anonymous namespace)::testStatus; 0x00405b64 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405b67 ja 0x405b71 | goto label_41; | } 0x00405b69 inc eax | eax++; 0x00405b6b mov dword [rip + 0x262e17], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_41: 0x00405b71 mov al, byte [r15] | al = *(r15); 0x00405b74 cmp al, 0xff | | if (al != 0xff) { 0x00405b76 je 0x405d50 | 0x00405b7c cmp al, 1 | | if (al != 1) { 0x00405b7e je 0x405d80 | 0x00405b84 jmp 0x405dac | goto label_42; 0x00405b89 lea rsi, [rsp + 0x18] | 0x00405b8e lea rdx, [rsp + 0x10] | 0x00405b93 mov rdi, r15 | 0x00405b96 mov ecx, 0xffffffff | 0x00405b9b call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405ba0 test eax, eax | | if (eax != 0) { 0x00405ba2 je 0x405bcd | 0x00405ba4 mov edi, 0x44f523 | 0x00405ba9 mov edx, 0x44d521 | edx = "0 == object->endConvert(b, &numOut)"; 0x00405bae mov esi, 0x209 | esi = 0x209; 0x00405bb3 xor eax, eax | eax = 0; 0x00405bb5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405bba mov eax, dword [rip + 0x262dc8] | eax = (anonymous namespace)::testStatus; 0x00405bc0 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405bc3 ja 0x405bcd | goto label_43; | } 0x00405bc5 inc eax | eax++; 0x00405bc7 mov dword [rip + 0x262dbb], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_43: 0x00405bcd cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405bd2 je 0x405bfd | 0x00405bd4 mov edi, 0x44f523 | 0x00405bd9 mov edx, 0x44d545 | edx = "0 == numOut"; 0x00405bde mov esi, 0x20a | esi = 0x20a; 0x00405be3 xor eax, eax | eax = 0; 0x00405be5 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405bea mov eax, dword [rip + 0x262d98] | eax = (anonymous namespace)::testStatus; 0x00405bf0 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405bf3 ja 0x405bfd | goto label_44; | } 0x00405bf5 inc eax | eax++; 0x00405bf7 mov dword [rip + 0x262d8b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_44: 0x00405bfd lea rsi, [rsp + 0x18] | 0x00405c02 lea rdx, [rsp + 0x10] | 0x00405c07 mov rdi, r15 | 0x00405c0a mov ecx, 0xffffffff | 0x00405c0f call 0x421800 | eax = intBloombergLP::bdlde::Base64Encoder::endConvert(char*,int*,int) (r15, rsp + 0x18, rsp + 0x10, 0xffffffff); 0x00405c14 cmp eax, 0xffffffff | | if (eax != 0xffffffff) { 0x00405c17 je 0x405c42 | 0x00405c19 mov edi, 0x44f523 | 0x00405c1e mov edx, 0x44d567 | edx = "-1 == object->endConvert(b, &numOut)"; 0x00405c23 mov esi, 0x20c | esi = 0x20c; 0x00405c28 xor eax, eax | eax = 0; 0x00405c2a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c2f mov eax, dword [rip + 0x262d53] | eax = (anonymous namespace)::testStatus; 0x00405c35 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405c38 ja 0x405c42 | goto label_45; | } 0x00405c3a inc eax | eax++; 0x00405c3c mov dword [rip + 0x262d46], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_45: 0x00405c42 cmp dword [rsp + 0x10], 0 | | if (*((rsp + 0x10)) != 0) { 0x00405c47 je 0x405c72 | 0x00405c49 mov edi, 0x44f523 | 0x00405c4e mov edx, 0x44d545 | edx = "0 == numOut"; 0x00405c53 mov esi, 0x20d | esi = 0x20d; 0x00405c58 xor eax, eax | eax = 0; 0x00405c5a call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c5f mov eax, dword [rip + 0x262d23] | eax = (anonymous namespace)::testStatus; 0x00405c65 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405c68 ja 0x405c72 | goto label_46; | } 0x00405c6a inc eax | eax++; 0x00405c6c mov dword [rip + 0x262d16], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_46: 0x00405c72 cmp byte [r15], 0xff | | if (*(r15) != 0xff) { 0x00405c76 je 0x405d31 | 0x00405c7c mov edi, 0x44f523 | 0x00405c81 mov edx, 0x44d58c | edx = "0 == object->isAcceptable()"; 0x00405c86 mov esi, 0x20f | esi = 0x20f; 0x00405c8b xor eax, eax | eax = 0; 0x00405c8d call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405c92 mov eax, dword [rip + 0x262cf0] | eax = (anonymous namespace)::testStatus; 0x00405c98 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405c9b ja 0x405ca5 | 0x00405c9d inc eax | eax++; 0x00405c9f mov dword [rip + 0x262ce3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405ca5 mov al, byte [r15] | al = *(r15); 0x00405ca8 cmp al, 1 | | if (al == 1) { 0x00405caa jne 0x405d04 | 0x00405cac cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) == 0) { 0x00405cb1 jne 0x405d01 | 0x00405cb3 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405cb7 mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405cbb test ecx, ecx | | if (ecx != 0) { 0x00405cbd je 0x405cd4 | 0x00405cbf lea esi, [rcx + 2] | esi = rcx + 2; 0x00405cc2 cdq | edx:eax = (int64_t) eax; 0x00405cc3 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405cc5 xor esi, esi | esi = 0; 0x00405cc7 cmp edx, ecx | 0x00405cc9 setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405ccd imul eax, ecx | eax *= ecx; 0x00405cd0 add eax, edx | eax += edx; 0x00405cd2 sub eax, esi | eax -= esi; | } 0x00405cd4 test al, 3 | | if ((al & 3) != 0) { 0x00405cd6 jne 0x405d01 | goto label_47; | } 0x00405cd8 mov edi, 0x44f523 | 0x00405cdd mov edx, 0x44d428 | edx = "0 == object->isDone()"; 0x00405ce2 mov esi, 0x210 | esi = 0x210; 0x00405ce7 xor eax, eax | eax = 0; 0x00405ce9 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405cee mov eax, dword [rip + 0x262c94] | eax = (anonymous namespace)::testStatus; 0x00405cf4 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405cf7 ja 0x405d01 | goto label_47; | } 0x00405cf9 inc eax | eax++; 0x00405cfb mov dword [rip + 0x262c87], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_47: 0x00405d01 mov al, byte [r15] | al = *(r15); | } 0x00405d04 cmp al, 0xff | | if (al == 0xff) { 0x00405d06 je 0x405d31 | goto label_48; | } 0x00405d08 mov edi, 0x44f523 | 0x00405d0d mov edx, 0x44d5a8 | edx = "1 == object->isError()"; 0x00405d12 mov esi, 0x211 | esi = 0x211; 0x00405d17 xor eax, eax | eax = 0; 0x00405d19 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405d1e mov eax, dword [rip + 0x262c64] | eax = (anonymous namespace)::testStatus; 0x00405d24 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405d27 ja 0x405d31 | goto label_48; | } 0x00405d29 inc eax | eax++; 0x00405d2b mov dword [rip + 0x262c57], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_48: 0x00405d31 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x00405d36 je 0x405e41 | goto label_49; | } | label_0: 0x00405d3c mov edi, 0x44f523 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"; 0x00405d41 mov edx, 0x44d473 | edx = "0 == object->outputLength()"; 0x00405d46 mov esi, 0x213 | esi = 0x213; 0x00405d4b jmp 0x405e1a | | } else { 0x00405d50 mov edi, 0x44f523 | 0x00405d55 mov edx, 0x44d40c | edx = "1 == object->isAcceptable()"; 0x00405d5a mov esi, 0x202 | esi = 0x202; 0x00405d5f xor eax, eax | eax = 0; 0x00405d61 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405d66 mov eax, dword [rip + 0x262c1c] | eax = (anonymous namespace)::testStatus; 0x00405d6c cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405d6f ja 0x405d79 | 0x00405d71 inc eax | eax++; 0x00405d73 mov dword [rip + 0x262c0f], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405d79 mov al, byte [r15] | al = *(r15); 0x00405d7c cmp al, 1 | | if (al != 1) { 0x00405d7e jne 0x405dac | goto label_42; | } | } 0x00405d80 cmp dword [r15 + 0x14], 0 | | if (*((r15 + 0x14)) == 0) { 0x00405d85 jne 0x405dac | 0x00405d87 mov ecx, dword [r15 + 4] | ecx = *((r15 + 4)); 0x00405d8b mov eax, dword [r15 + 0xc] | eax = *((r15 + 0xc)); 0x00405d8f test ecx, ecx | | if (ecx != 0) { 0x00405d91 je 0x405da8 | 0x00405d93 lea esi, [rcx + 2] | esi = rcx + 2; 0x00405d96 cdq | edx:eax = (int64_t) eax; 0x00405d97 idiv esi | eax = edx:eax / esi; | edx = edx:eax % esi; 0x00405d99 xor esi, esi | esi = 0; 0x00405d9b cmp edx, ecx | 0x00405d9d setg sil | sil = (edx > ecx) ? 1 : 0; 0x00405da1 imul eax, ecx | eax *= ecx; 0x00405da4 add eax, edx | eax += edx; 0x00405da6 sub eax, esi | eax -= esi; | } 0x00405da8 test al, 3 | | if ((al & 3) == 0) { 0x00405daa je 0x405dd5 | goto label_50; | } | } | label_42: 0x00405dac mov edi, 0x44f523 | 0x00405db1 mov edx, 0x44d551 | edx = "1 == object->isDone()"; 0x00405db6 mov esi, 0x203 | esi = 0x203; 0x00405dbb xor eax, eax | eax = 0; 0x00405dbd call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405dc2 mov eax, dword [rip + 0x262bc0] | eax = (anonymous namespace)::testStatus; 0x00405dc8 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405dcb ja 0x405dd5 | 0x00405dcd inc eax | eax++; 0x00405dcf mov dword [rip + 0x262bb3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_50: 0x00405dd5 cmp byte [r15], 0xff | | if (*(r15) == 0xff) { 0x00405dd9 jne 0x405e04 | 0x00405ddb mov edi, 0x44f523 | 0x00405de0 mov edx, 0x44d43e | edx = "0 == object->isError()"; 0x00405de5 mov esi, 0x204 | esi = 0x204; 0x00405dea xor eax, eax | eax = 0; 0x00405dec call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405df1 mov eax, dword [rip + 0x262b91] | eax = (anonymous namespace)::testStatus; 0x00405df7 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405dfa ja 0x405e04 | goto label_51; | } 0x00405dfc inc eax | eax++; 0x00405dfe mov dword [rip + 0x262b84], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_51: 0x00405e04 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) == 0) { 0x00405e09 je 0x405e7d | goto label_52; | } | label_2: 0x00405e0b mov edi, 0x44f523 | 0x00405e10 mov edx, 0x44d473 | edx = "0 == object->outputLength()"; 0x00405e15 mov esi, 0x206 | esi = 0x206; | } | } | label_12: 0x00405e1a xor eax, eax | eax = 0; 0x00405e1c call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e21 mov eax, dword [rip + 0x262b61] | eax = (anonymous namespace)::testStatus; 0x00405e27 cmp eax, 0x64 | | if (eax > 0x64) { 0x00405e2a ja 0x405e34 | goto label_1; | } 0x00405e2c inc eax | eax++; 0x00405e2e mov dword [rip + 0x262b54], eax | *(obj._anonymous_namespace_::testStatus) = eax; | do { | label_1: 0x00405e34 add rsp, 0x20 | 0x00405e38 pop rbx | 0x00405e39 pop r12 | 0x00405e3b pop r14 | 0x00405e3d pop r15 | 0x00405e3f pop rbp | 0x00405e40 ret | return rax; | label_49: 0x00405e41 cmp byte [r15], 0 | 0x00405e45 jne 0x405e34 | | } while (*(r15) != 0); 0x00405e47 mov edi, 0x44f523 | 0x00405e4c mov edx, 0x44d4db | edx = "0 == object->isInitialState()"; 0x00405e51 mov esi, 0x212 | esi = 0x212; 0x00405e56 xor eax, eax | eax = 0; 0x00405e58 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e5d mov eax, dword [rip + 0x262b25] | eax = (anonymous namespace)::testStatus; 0x00405e63 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405e66 ja 0x405e70 | 0x00405e68 inc eax | eax++; 0x00405e6a mov dword [rip + 0x262b18], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405e70 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405e75 jne 0x405d3c | goto label_0; | } 0x00405e7b jmp 0x405e34 | goto label_1; | label_52: 0x00405e7d cmp byte [r15], 0 | | if (*(r15) != 0) { 0x00405e81 jne 0x405e34 | goto label_1; | } 0x00405e83 mov edi, 0x44f523 | 0x00405e88 mov edx, 0x44d4db | edx = "0 == object->isInitialState()"; 0x00405e8d mov esi, 0x205 | esi = 0x205; 0x00405e92 xor eax, eax | eax = 0; 0x00405e94 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405e99 mov eax, dword [rip + 0x262ae9] | eax = (anonymous namespace)::testStatus; 0x00405e9f cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405ea2 ja 0x405eac | 0x00405ea4 inc eax | eax++; 0x00405ea6 mov dword [rip + 0x262adc], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405eac cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405eb1 jne 0x405e0b | goto label_2; | } 0x00405eb7 jmp 0x405e34 | goto label_1; | label_18: 0x00405ebc mov edi, 0x44f523 | 0x00405ec1 mov edx, 0x44d4db | edx = "0 == object->isInitialState()"; 0x00405ec6 mov esi, 0x1de | esi = 0x1de; 0x00405ecb xor eax, eax | eax = 0; 0x00405ecd call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405ed2 mov eax, dword [rip + 0x262ab0] | eax = (anonymous namespace)::testStatus; 0x00405ed8 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405edb ja 0x405ee5 | 0x00405edd inc eax | eax++; 0x00405edf mov dword [rip + 0x262aa3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405ee5 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405eea jne 0x405e34 | goto label_1; | } 0x00405ef0 jmp 0x4055a2 | goto label_3; | label_27: 0x00405ef5 mov edi, 0x44f523 | 0x00405efa mov edx, 0x44d4db | edx = "0 == object->isInitialState()"; 0x00405eff mov esi, 0x1eb | esi = 0x1eb; 0x00405f04 xor eax, eax | eax = 0; 0x00405f06 call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405f0b mov eax, dword [rip + 0x262a77] | eax = (anonymous namespace)::testStatus; 0x00405f11 cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405f14 ja 0x405f1e | 0x00405f16 inc eax | eax++; 0x00405f18 mov dword [rip + 0x262a6a], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405f1e cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405f23 jne 0x405e34 | goto label_1; | } 0x00405f29 jmp 0x4057ec | goto label_4; | label_39: 0x00405f2e mov edi, 0x44f523 | 0x00405f33 mov edx, 0x44d4db | edx = "0 == object->isInitialState()"; 0x00405f38 mov esi, 0x1fb | esi = 0x1fb; 0x00405f3d xor eax, eax | eax = 0; 0x00405f3f call 0x404550 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bdl/bdlde/bdlde_base64encoder.t.cpp(%d): %s (failed)\n"); 0x00405f44 mov eax, dword [rip + 0x262a3e] | eax = (anonymous namespace)::testStatus; 0x00405f4a cmp eax, 0x64 | | if (eax <= 0x64) { 0x00405f4d ja 0x405f57 | 0x00405f4f inc eax | eax++; 0x00405f51 mov dword [rip + 0x262a31], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } 0x00405f57 cmp dword [r15 + 0xc], 0 | | if (*((r15 + 0xc)) != 0) { 0x00405f5c jne 0x405e34 | goto label_1; | } 0x00405f62 jmp 0x405ae9 | goto label_5; | }