LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFilePrintParameters.h
// Function: PhotonFilePrintParameters::PhotonFilePrintParameters(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PhotonFilePrintParameters(int parametersPos, const std::string & fileContent) {
        std::string data(fileContent.begin() + parametersPos, fileContent.begin() + parametersPos + getByteSize());
		std::stringstream ss(data);
        PhotonInputStream ds(ss);

        bottomLiftDistance_ = ds.readFloat();
        bottomLiftSpeed_ = ds.readFloat();

        liftingDistance_ = ds.readFloat();
        liftingSpeed_ = ds.readFloat();
        retractSpeed_ = ds.readFloat();

        volumeMl_ = ds.readFloat();
        weightG_ = ds.readFloat();
        costDollars_ = ds.readFloat();

        bottomLightOffDelay_ = ds.readFloat();
        lightOffDelay_ = ds.readFloat();
        bottomLayerCount_ = ds.readInt();

        p1_ = ds.readInt();
        p2_ = ds.readInt();
        p3_ = ds.readInt();
        p4_ = ds.readInt();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movaps 0x4792(%rip), %xmm0     # 0xd020
movups %xmm0, (%rdi)
movl $0x43960000, 0x10(%rdi) # imm = 0x43960000
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movl $0x0, 0x24(%rdi)
movq (%rdx), %rax
movslq %esi, %rcx
leaq (%rax,%rcx), %rsi
leaq 0x3c(%rax,%rcx), %rdx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x9ff2
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x2350
leaq -0x28(%rbp), %rdi
movq %r14, (%rdi)
callq 0x9d04
movl %eax, (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x4(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x8(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0xc(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
leaq 0x14(%rbx), %rcx
movl %eax, (%rcx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x18(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x1c(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x20(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x24(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x28(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x2c(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x30(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x34(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9d04
movl %eax, 0x38(%rbx)
movq 0x9607(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x89c7
callq 0x21d0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x89fe
movq %rax, %rbx
movq 0x95c2(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x8a0c
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::saveLayer(PhotonLayer&)
void saveLayer(PhotonLayer & photonLayer) {
        packedLayerImage_ = photonLayer.packLayerImage();
        imageData_ = photonLayer.packImageData();
        dataSize_ = imageData_.size();
        islandRows_.clear();
        isLandsCount_ = photonLayer.setIslands(islandRows_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xb922
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x2270
movq (%r15), %rdi
leaq -0x30(%rbp), %r12
cmpq %r12, %rdi
je 0x8e92
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0xba6a
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x2270
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x8eb6
callq 0x21d0
movl 0x30(%rbx), %eax
movl %eax, 0x10(%rbx)
leaq 0x68(%rbx), %r15
movq 0x68(%rbx), %rsi
movq %r15, %rdi
callq 0xbd9c
movq %r14, %rdi
movq %r15, %rsi
callq 0xbbc2
movl %eax, 0x80(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFilePreview.h
// Function: PhotonFilePreview::save(PhotonOutputStream, int)
void save(PhotonOutputStream os, int startAddress) {
        os.writeInt(resolutionX_);
        os.writeInt(resolutionY_);
        os.writeInt(startAddress + 4+4+4+4 + 4+4+4+4);
        os.writeInt(dataSize_);
        os.writeInt(p1_);
        os.writeInt(p2_);
        os.writeInt(p3_);
        os.writeInt(p4_);
        os.write(rawImageData_, 0, dataSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %rsi, (%r14)
movl (%rdi), %esi
movq %r14, %rdi
callq 0xbff4
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
addl $0x20, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0xbff4
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
movl 0x44(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
movl 0x4c(%rbx), %esi
movq %r14, %rdi
callq 0xbff4
leaq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x9c04
movq (%r14), %rsi
cmpq 0x8(%r14), %rsi
je 0x9127
movslq 0xc(%rbx), %rdx
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x9134
movq %rsi, %rdi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x9150
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFilePrintParameters.h
// Function: PhotonFilePrintParameters::save(PhotonOutputStream&)
void save(PhotonOutputStream & os) {
        os.writeFloat(bottomLiftDistance_);
        os.writeFloat(bottomLiftSpeed_);

        os.writeFloat(liftingDistance_);
        os.writeFloat(liftingSpeed_);
        os.writeFloat(retractSpeed_);

        os.writeFloat(volumeMl_);
        os.writeFloat(weightG_);
        os.writeFloat(costDollars_);

        os.writeFloat(bottomLightOffDelay_);
        os.writeFloat(lightOffDelay_);
        os.writeInt(bottomLayerCount_);

        os.writeInt(p1_);
        os.writeInt(p2_);
        os.writeInt(p3_);
        os.writeInt(p4_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x34(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x38(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbff4
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::save(PhotonOutputStream&)
void save(PhotonOutputStream & os) {
        os.writeFloat(layerPositionZ_);
        os.writeFloat(layerExposure_);
        os.writeFloat(layerOffTimeSeconds_);

        os.writeInt(dataAddress_);
        os.writeInt(dataSize_);

        os.writeInt(unknown1_);
        os.writeInt(unknown2_);
        os.writeInt(unknown3_);
        os.writeInt(unknown4_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0xbff4
movl 0x20(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbff4
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonInputStream.h
// Function: PhotonInputStream::readInt()
uint32_t readInt() {
		std::vector<char> buf;
		buf.resize(4);
        readFully(buf);
        return (buf[3]) << 24 | (buf[2] & 0xff) << 16 |
                (buf[1] & 0xff) << 8 | (buf[0] & 0xff);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x4, %esi
callq 0x9432
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
cmpq %rdx, %rsi
je 0x9d48
movq (%rbx), %rdi
subq %rsi, %rdx
callq 0x2280
movq -0x20(%rbp), %rsi
movl (%rsi), %ebx
movq %rsi, %rdi
callq 0x21d0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x9d6c
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFilePreview.h
// Function: PhotonFilePreview::decodeImageData()
void decodeImageData() {
        imageData_.resize(resolutionX_ * resolutionY_);
        int d = 0;
        for (int i = 0; i < dataSize_; i++) {
			int32_t dot = (rawImageData_[i] & 0xFF) | ((rawImageData_[i+1] & 0xFF) << 8);
			i++;

			int32_t color =   ((dot & 0xF800) << 8) | ((dot & 0x07C0) << 5) | ((dot & 0x001F) << 3);

//            int red = ((dot >> 11) & 0x1F) << 3;
//            int green = ((dot >> 6) & 0x1F) << 3;
//            int blue = (dot & 0x1F) << 3;
//            color = red<<16 | green<<8 | blue;

            int repeat = 1;
            if ((dot & 0x0020) == 0x0020) {
                repeat += (rawImageData_[i+1] & 0xFF) | ((rawImageData_[i+2] & 0x0F) << 8);
				i += 2;
            }

            while (repeat > 0) {
                imageData_[d++] = color;
                repeat--;
            }
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x28, %rdi
movslq (%rbx), %rax
movslq 0x4(%rbx), %rsi
imulq %rax, %rsi
callq 0x9464
cmpl $0x0, 0xc(%rbx)
jle 0x9fea
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
xorl %esi, %esi
movslq %esi, %r8
movzbl (%rax,%r8), %edi
testb $0x20, %dil
jne 0x9f79
leaq 0x1(%r8), %rsi
movl $0x1, %r9d
jmp 0x9f97
movzbl 0x2(%rax,%r8), %r9d
leaq 0x3(%r8), %rsi
movzbl 0x3(%rax,%r8), %r10d
andl $0xf, %r10d
shll $0x8, %r10d
addl %r10d, %r9d
incl %r9d
movzbl 0x1(%rax,%r8), %r10d
movl %r10d, %r8d
shll $0x10, %r8d
leal (%r8,%rdi,8), %r8d
shll $0xd, %r10d
shll $0x5, %edi
orl %r10d, %edi
andl $0xf800, %edi           # imm = 0xF800
andl $0xf800f8, %r8d         # imm = 0xF800F8
orl %edi, %r8d
movslq %edx, %rdi
leal (%rdi,%r9), %edx
leaq (%rcx,%rdi,4), %rdi
movl %r9d, %r9d
xorl %r10d, %r10d
movl %r8d, (%rdi,%r10,4)
incq %r10
cmpl %r10d, %r9d
jne 0x9fd3
incl %esi
cmpl 0xc(%rbx), %esi
jl 0x9f5f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::PhotonFileLayer(PhotonInputStream&, int, int)
PhotonFileLayer(PhotonInputStream & ds, int32_t width, int32_t height) {
		width_ = width;
		height_ = height;
		layerPositionZ_ = ds.readFloat();
        layerExposure_ = ds.readFloat();
        layerOffTimeSeconds_ = ds.readFloat();

        dataAddress_ = ds.readInt();
        dataSize_ = ds.readInt();

        unknown1_ = ds.readInt();
        unknown2_ = ds.readInt();
        unknown3_ = ds.readInt();
        unknown4_ = ds.readInt();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %r14
movq %r14, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x68(%rdi), %rsi
movq %rsi, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rdi)
movq %rax, 0x78(%rdi)
leaq 0x90(%rdi), %r12
movups %xmm0, 0x90(%rdi)
movq %rax, 0xa0(%rdi)
movl %edx, 0xac(%rdi)
movl %ecx, 0xb0(%rdi)
movq %r15, %rdi
callq 0x9d04
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x4(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0xc(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x10(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x14(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x18(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x1c(%rbx)
movq %r15, %rdi
callq 0x9d04
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x9380
movq -0x30(%rbp), %rdi
callq 0xa400
movq 0x48(%rbx), %rdi
cmpq %r14, %rdi
je 0xa2a5
callq 0x21d0
movq 0x28(%rbx), %rdi
cmpq %r13, %rdi
je 0xa2b3
callq 0x21d0
movq %r15, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::unLink()
void unLink() {
        iArray.clear();
        pixels.clear();
        rowIslands.clear();
        rowUnsupported.clear();
        rowSupported.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0xb8e0
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0xa3ce
movq %rax, 0x30(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0xa3dc
movq %rax, 0x48(%rbx)
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0xa3ea
movq %rax, 0x60(%rbx)
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0xa3f8
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::packLayerImage[abi:cxx11]()
std::string packLayerImage() {
		std::stringstream baos;

		{
            for (int y = 0; y < height_; y++) {
                if (pixels[y] == 0) {
                    add(baos, PhotonDot::OFF, width_);
                } else {
                    char current = PhotonDot::OFF;
                    int length = 0;
                    for (int x = 0; x < width_; x++) {
						char next = iArray[y][x];
                        if (next != current) {
                            if (length > 0) {
                                add(baos, current, length);
                            }
                            current = next;
                            length = 1;
                        } else {
                            length++;
                        }
                    }
                    if (length > 0) {
                        add(baos, current, length);
                    }
                }
            }

			return baos.str();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2160
cmpl $0x0, 0x4(%r14)
jle 0xb9f2
xorl %r12d, %r12d
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r12,4)
movl (%r14), %ecx
je 0xb9d1
testl %ecx, %ecx
jle 0xb9e2
xorl %r13d, %r13d
leaq (%r12,%r12,2), %rbx
xorl %eax, %eax
xorl %edx, %edx
movq 0x10(%r14), %rsi
movq (%rsi,%rbx,8), %rsi
movb (%rsi,%r13), %r15b
cmpb %dl, %r15b
jne 0xb989
incl %eax
jmp 0xb9ac
testl %eax, %eax
jle 0xb9a4
movsbl %dl, %edx
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl %eax, %ecx
callq 0xbc5a
movl (%r14), %ecx
movl %r15d, %edx
movl $0x1, %eax
incq %r13
movslq %ecx, %rsi
cmpq %rsi, %r13
jl 0xb974
testl %eax, %eax
jle 0xb9e2
movsbl %dl, %edx
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl %eax, %ecx
callq 0xbc5a
jmp 0xb9e2
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
xorl %edx, %edx
callq 0xbc5a
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xb957
leaq -0x1a0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2340
movq 0x659c(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xba3f
jmp 0xba3f
jmp 0xba3f
movq %rax, %rbx
movq 0x655f(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::packImageData[abi:cxx11]()
std::string packImageData() {
		std::stringstream baos;
		
		{
            for (int y = 0; y < height_; y++) {
                if (pixels[y] == 0) {
                    addPhotonRLE(baos, true, width_);
                } else {
                    char current = PhotonDot::OFF;
                    int length = 0;
                    for (int x = 0; x < width_; x++) {
						char next = iArray[y][x];
                        if (next != current) {
                            if (length > 0) {
                                addPhotonRLE(baos, current == PhotonDot::OFF, length);
                            }
                            current = next;
                            length = 1;
                        } else {
                            length++;
                        }
                    }
                    if (length > 0) {
                        addPhotonRLE(baos, current == PhotonDot::OFF, length);
                    }
                }
            }

            return baos.str();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2160
cmpl $0x0, 0x4(%r14)
jle 0xbb4b
xorl %r12d, %r12d
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r12,4)
movl (%r14), %ecx
je 0xbb27
testl %ecx, %ecx
jle 0xbb3b
xorl %r13d, %r13d
leaq (%r12,%r12,2), %rbx
xorl %eax, %eax
xorl %esi, %esi
movq 0x10(%r14), %rdx
movq (%rdx,%rbx,8), %rdx
movb (%rdx,%r13), %r15b
cmpb %sil, %r15b
jne 0xbad5
incl %eax
jmp 0xbafd
testl %eax, %eax
jle 0xbaf5
xorl %edx, %edx
testb %sil, %sil
sete %dl
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl %eax, %ecx
callq 0xbcf6
movl (%r14), %ecx
movl %r15d, %esi
movl $0x1, %eax
incq %r13
movslq %ecx, %rdx
cmpq %rdx, %r13
jl 0xbac0
testl %eax, %eax
jle 0xbb3b
xorl %edx, %edx
testb %sil, %sil
sete %dl
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl %eax, %ecx
callq 0xbcf6
jmp 0xbb3b
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl $0x1, %edx
callq 0xbcf6
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xba9f
leaq -0x1a0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2340
movq 0x6443(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb98
jmp 0xbb98
jmp 0xbb98
movq %rax, %rbx
movq 0x6406(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::setIslands(std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>>&)
int setIslands(std::vector<photoncpp::BitSet> & islandRows) {
        int islands = 0;
        for (int y = 0; y < height_; y++) {
			photoncpp::BitSet bitSet;
            if (rowIslands[y] > 0) {
                for (int x = 0; x < width_; x++) {
                    if (iArray[y][x] == PhotonDot::ISLAND) {
						bitSet[x] = true;
                    }
                }
            }
            islandRows.push_back(bitSet);
            islands += rowIslands[y];
        }
        return islands;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x4(%rdi)
jle 0xbc2c
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r13, -0x50(%rbp)
movl %r13d, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movl %r13d, -0x38(%rbp)
movq %r13, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xbdcc
movq 0x40(%r14), %rax
addl (%rax,%r12,4), %r15d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xbc1e
callq 0x21d0
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xbbe8
jmp 0xbc2f
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xbc52
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::add(std::ostream&, char, int)
void add(std::ostream & baos, char current, int length) {
        if (length < 32) {
			std::vector<char> data(1, 0);
            data[0] = (char) ((current << 5) | (length & 0x1f));
            baos.write(data.data(), data.size());
        } else {
			std::vector<char> data(2, 0);
            data[0] = (char) (0x80 | (current << 5) | (length >> 8 & 0x00FF));
            data[1] = (char) (length & 0x00FF);
            baos.write(data.data(), data.size());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r14
shll $0x5, %r12d
cmpl $0x1f, %ecx
jg 0xbca0
movl $0x1, %edi
callq 0x21f0
movq %rax, %rbx
andl $0x1f, %r15d
orl %r15d, %r12d
movb %r12b, (%rax)
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x22a0
jmp 0xbcd1
movl $0x2, %edi
callq 0x21f0
movq %rax, %rbx
movl %r15d, %eax
shrl $0x8, %eax
orl %eax, %r12d
orb $-0x80, %r12b
movb %r12b, (%rbx)
movb %r15b, 0x1(%rbx)
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22a0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
jmp 0xbce3
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O3/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::addPhotonRLE(std::ostream&, bool, int)
void addPhotonRLE(std::ostream & baos, bool off, int length) {
		std::vector<char> data({ 0 });
        while (length>0) {
            int lineLength = std::min(length, 125); // max storage length of 0x7D (125) ?? Why not 127?
            data[0] = (char) ((off ? 0x00: 0x80) | (lineLength & 0x7f));
            baos.write(data.data(), data.size());
            length -= lineLength;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
leaq -0x22(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
leaq -0x21(%rbp), %rcx
movl $0x1, %edx
callq 0x9e88
testl %ebx, %ebx
jle 0xbd67
xorb $0x1, %r15b
movzbl %r15b, %r15d
shll $0x7, %r15d
cmpl $0x7d, %ebx
movl $0x7d, %r12d
cmovbl %ebx, %r12d
movl %r12d, %eax
orl %r15d, %eax
movq -0x40(%rbp), %rcx
movb %al, (%rcx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x22a0
subl %r12d, %ebx
jg 0xbd36
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xbd75
callq 0x21d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xbd93
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_create
void test_create(void) {
	// Δημιουργούμε μια κενή λίστα με NULL δείκτη συνάρτησης delete_value
	List list = list_create(NULL);
	list_set_destroy_value(list, NULL);

	// Ελέγχουμε ότι δεν απέτυχε η malloc στην λίστα, και ότι
	// αρχικοποιείται με μέγεθος 0 (δηλαδή χωρίς κόμβους)
	TEST_ASSERT(list != NULL);
	TEST_ASSERT(list_size(list) == 0);

	list_destroy(list);
}

// Assembly:
pushq %rbx
xorl %edi, %edi
callq 0x4814
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x496f
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x165f(%rip), %rsi      # 0x5318
leaq 0x18da(%rip), %rcx      # 0x559a
leaq 0x1660(%rip), %r8       # 0x5327
movl $0x14, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3d15
movq %rbx, %rdi
callq 0x4856
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x162a(%rip), %rsi      # 0x5318
leaq 0x18a5(%rip), %rcx      # 0x559a
leaq 0x1638(%rip), %r8       # 0x5334
movl $0x15, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3d15
movq %rbx, %rdi
popq %rbx
jmp 0x4978
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find
void test_find(void) {
	List list = list_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	// Εισάγουμε δοκιμαστικές τιμές στον πίνακα, για να ελέγξουμε την test_find
	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Εύρεση όλων των στοιχείων
	for (int i = 0; i < N; i++) {
		int* value = list_find(list, &i, compare_ints); 
		TEST_ASSERT(value == &array[i]);
	}

	// Δοκιμάζουμε, για μια τυχαία τιμή που δεν μπορεί πιθανώς να υπάρχει στην λίστα,
	// αν η list_find γυρνάει σωστά NULL pointer
	int not_exists = -1;
	TEST_ASSERT(list_find(list, &not_exists, compare_ints) == NULL);

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4814
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x485a
incq %r12
addq $0x4, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x4088
movq %rsp, %r15
movl $0x0, (%r15)
leaq 0x125f(%rip), %r13      # 0x5318
leaq 0x14da(%rip), %rbp      # 0x559a
leaq 0x1398(%rip), %r12      # 0x545f
movq %rbx, %rdi
movq %r15, %rsi
leaq -0x79(%rip), %rdx       # 0x405b
callq 0x4904
movslq (%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %r13, %rsi
movl $0x7d, %edx
movq %rbp, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x417a
movl (%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rsp)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x40c7
leaq 0x4(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq -0xca(%rip), %rdx       # 0x405b
movq %rbx, %rdi
callq 0x4904
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0x11db(%rip), %rsi      # 0x5318
leaq 0x1456(%rip), %rcx      # 0x559a
leaq 0x1327(%rip), %r8       # 0x5472
movl $0x83, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x417a
movq %rbx, %rdi
callq 0x4978
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find_node
void test_find_node(void) {
	List list = list_create(NULL);

	// Εισαγωγή τιμών στον πίνακα
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Ξεκινάμε από την αρχή της λίστας
	ListNode node = list_first(list);

	for (int i = N - 1; i >= 0; i--) {
		// Ελέγχουμε ότι η list_find_node βρίσκει σωστά τον πρώτο κόμβο με value τον δείκτη &array[i].
		// Σε αυτή την λίστα, δοκιμάζουμε ότι ο πρώτος κόμβος περιέχει τον δείκτη &array[N - 1], 
		// o δεύτερος τον &array[998] κοκ
		ListNode found_node = list_find_node(list, &i, compare_ints); 
		TEST_ASSERT(found_node == node);
		TEST_ASSERT(list_node_value(list, found_node) == &array[i]);

		// Προχωράμε στον επόμενο κόμβο για να προσπελάσουμε όλη την λίστα
		node = list_next(list, node);
	}

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4814
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x485a
incq %r12
addq $0x4, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x41a7
movq %rbx, %rdi
callq 0x49b9
movq %rax, %r12
leaq 0x4(%rsp), %rax
movl $0x3e7, (%rax)          # imm = 0x3E7
leaq 0x1134(%rip), %rbp      # 0x5318
leaq 0x13af(%rip), %r13      # 0x559a
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
leaq -0x19f(%rip), %rdx      # 0x405b
callq 0x4943
movq %rax, %r15
xorl %edi, %edi
cmpq %r12, %rax
sete %dil
movq %rbp, %rsi
movl $0x9e, %edx
movq %r13, %rcx
leaq 0x1288(%rip), %r8       # 0x54a5
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x42a2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49f7
movslq 0x4(%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %rbp, %rsi
movl $0x9f, %edx
movq %r13, %rcx
leaq 0x1261(%rip), %r8       # 0x54b8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x42a2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49ce
movq %rax, %r12
movl 0x4(%rsp), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
testl %eax, %eax
jg 0x41eb
movq %rbx, %rdi
callq 0x4978
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: t1
int t1(void)
{
    try
    {
        return(6);
    }
    catch (Throwable, e)
    {
        printf("%s\n", e->getMessage());
    }
    finally;
    return(7);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xaf0e(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x70ab(%rip), %r14      # 0xa418
movl $0x6f, %edx
movq %r14, %rsi
callq 0x157c
leaq 0xaf6f(%rip), %r15      # 0xe2f0
leaq 0xad38(%rip), %r12      # 0xe0c0
movl $0x1, %r13d
movq (%rbp), %rdi
callq 0x1334
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x6f, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x33d1
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x33d1
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x3529
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl $0x73, %r8d
callq 0x1c49
testl %eax, %eax
je 0x342e
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x342e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1904
testl %eax, %eax
je 0x342e
movq 0x8(%rbx), %rdi
movl %r13d, %esi
callq 0x1f9d
movq (%rbx), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
cmpl $0x0, 0xaebb(%rip)      # 0xe2f0
je 0x338e
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x346c
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x346c
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x338e
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x34a4
movq (%rbp), %rdi
callq 0x195a
testl %eax, %eax
je 0x34c6
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x34a4
jmp 0x3482
movq (%rbp), %rdi
callq 0x12fc
movl $0x7, %r14d
cmpl $-0x1, %eax
je 0x359a
movq (%rbp), %rdi
leaq 0x6f2f(%rip), %rdx      # 0xa418
movl $0xc8, %esi
movl $0x78, %ecx
callq 0x21ae
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3591
movq %rbx, %rdi
callq 0x1040
jmp 0x359a
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x12fc
movl $0x6, %ebp
cmpl $-0x1, %eax
je 0x35a7
leaq 0x6ec9(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x71, %ecx
callq 0x21ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x1334
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x359f
movq %r14, %rdi
callq 0x1040
jmp 0x35a7
movq (%rbp), %rdi
callq 0x1b77
movl %r14d, %eax
jmp 0x35a9
movq %rbx, %rdi
callq 0x1b77
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: t2
int t2(void)
{
    try
    {
        return(6);
    }
    finally
    {
        return(7);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xaca6(%rip), %r13      # 0xe270
movq (%r13), %rdi
leaq 0x6e43(%rip), %r14      # 0xa418
movl $0x7d, %ebp
movq %r14, %rsi
movl %ebp, %edx
callq 0x157c
leaq 0xad09(%rip), %r15      # 0xe2f4
movl $0x1, %r12d
movq (%r13), %rdi
callq 0x1334
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x3631
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3631
addq $0x8, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
je 0x3721
cmpl $0x0, 0xacbc(%rip)      # 0xe2f4
je 0x35f1
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x3668
addq $0xd0, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
jne 0x3668
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x35f1
movq (%r13), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%r13), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x36a4
movq (%r13), %rdi
callq 0x195a
testl %eax, %eax
je 0x3789
movq (%r13), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jle 0x367e
movq (%r13), %rdi
callq 0x12fc
movl $0x7, %ebp
cmpl $-0x1, %eax
je 0x379e
movq (%r13), %rdi
leaq 0x6d32(%rip), %rdx      # 0xa418
movl $0xc8, %esi
movl $0x83, %ecx
callq 0x21ae
movq %rax, %rbx
movq (%r13), %rdi
callq 0x1334
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3790
movq %rbx, %rdi
jmp 0x3782
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x12fc
movl $0x6, %ebp
cmpl $-0x1, %eax
je 0x379e
leaq 0x6cd1(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x7f, %ecx
callq 0x21ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x1334
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3796
movq %r14, %rdi
callq 0x1040
jmp 0x379e
movl $0x6, %eax
jmp 0x37a0
movq (%r13), %rdi
jmp 0x3799
movq %rbx, %rdi
callq 0x1b77
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: t3
int t3(void)
{
    try
    {
        assert(0);
    }
    catch (FailedAssertion, e)
    {
        return(8);
    }
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xaaaf(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x6c4c(%rip), %r14      # 0xa418
movl $0x89, %edx
movq %r14, %rsi
callq 0x157c
leaq 0xab18(%rip), %r15      # 0xe2f8
leaq 0xa939(%rip), %r12      # 0xe120
movl $0x1, %r13d
movq (%rbp), %rdi
callq 0x1334
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x89, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x382c
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x382c
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x3867
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl $0x8d, %r8d
callq 0x1c49
testl %eax, %eax
je 0x388e
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x388e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1904
testl %eax, %eax
je 0x388e
jmp 0x392a
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
leaq 0x6ab2(%rip), %rdx      # 0xa332
movq %r14, %rcx
movl $0x8b, %r8d
callq 0x20cc
cmpl $0x0, 0xaa63(%rip)      # 0xe2f8
je 0x37ed
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x38cc
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x38cc
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x37ed
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x3908
movq (%rbp), %rdi
callq 0x195a
testl %eax, %eax
je 0x39a3
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x3908
jmp 0x38e2
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x1f9d
movq (%rbx), %rax
movl $0x2, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x12fc
cmpl $-0x1, %eax
je 0x39a3
leaq 0x6abf(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x8f, %ecx
callq 0x21ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x1334
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x399b
movq %r14, %rdi
callq 0x1040
jmp 0x39a3
movq %rbx, %rdi
callq 0x1b77
movl $0x8, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: t4
int t4(void)
{
    try
    {
        assert(0);
    }
    catch (FailedAssertion, e)
    {
        return(8);
    }
    finally
    {
        return(9);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xa8a7(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x6a44(%rip), %r14      # 0xa418
movl $0x96, %edx
movq %r14, %rsi
callq 0x157c
leaq 0xa914(%rip), %r15      # 0xe2fc
leaq 0xa731(%rip), %r12      # 0xe120
movl $0x1, %r13d
movq (%rbp), %rdi
callq 0x1334
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x96, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x3a34
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3a34
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x3a6f
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl $0x9a, %r8d
callq 0x1c49
testl %eax, %eax
je 0x3a96
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x3a96
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1904
testl %eax, %eax
je 0x3a96
jmp 0x3ba4
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
leaq 0x68aa(%rip), %rdx      # 0xa332
movq %r14, %rcx
movl $0x98, %r8d
callq 0x20cc
cmpl $0x0, 0xa85f(%rip)      # 0xe2fc
je 0x39f5
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x3ad4
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x3ad4
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x39f5
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x3b10
movq (%rbp), %rdi
callq 0x195a
testl %eax, %eax
je 0x3b9a
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jle 0x3aea
movq (%rbp), %rdi
callq 0x12fc
movl $0x9, %r14d
cmpl $-0x1, %eax
je 0x3c23
movq (%rbp), %rdi
leaq 0x68c5(%rip), %rdx      # 0xa418
movl $0xc8, %esi
movl $0xa0, %ecx
callq 0x21ae
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3c1a
movq %rbx, %rdi
callq 0x1040
jmp 0x3c23
movl $0x8, %eax
jmp 0x3c32
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x1f9d
movq (%rbx), %rax
movl $0x2, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x12fc
movl $0x8, %ebp
cmpl $-0x1, %eax
je 0x3c30
leaq 0x6840(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x9c, %ecx
callq 0x21ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x1334
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3c28
movq %r14, %rdi
callq 0x1040
jmp 0x3c30
movq (%rbp), %rdi
callq 0x1b77
movl %r14d, %eax
jmp 0x3c32
movq %rbx, %rdi
callq 0x1b77
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: recurse
void recurse(int x)
{
    printf("recurse(%d)\n", x);

    try
    {
        if (x == 0)
            *((int *)0) = 0;
        recurse(x - 1);
    }
    finally
        printf("%d, ", x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5e51(%rip), %rdi      # 0xa42e
xorl %eax, %eax
movl %ebx, %esi
callq 0x1080
leaq 0x9c83(%rip), %r15      # 0xe270
movq (%r15), %rdi
leaq 0x5e21(%rip), %rsi      # 0xa418
movl $0x2cd, %ebp            # imm = 0x2CD
movl %ebp, %edx
callq 0x157c
movl %ebx, %eax
decl %eax
movl %eax, 0x4(%rsp)
leaq 0x9d06(%rip), %r12      # 0xe318
movl $0x1, %r13d
movq (%r15), %rdi
callq 0x1334
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
leaq 0x5de8(%rip), %rdx      # 0xa418
movl %ebp, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x466d
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x466d
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x466d
movq (%r14), %rax
movl $0x1, 0x1b8(%rax)
movl 0x4(%rsp), %edi
callq 0x45c9
cmpl $0x0, 0x9ca4(%rip)      # 0xe318
je 0x4618
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x46a7
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x46a7
movq (%r14), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x4618
movq (%r15), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
leaq 0x5d78(%rip), %r14      # 0xa43b
xorl %ebp, %ebp
movq (%r15), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x46f3
movq (%r15), %rdi
callq 0x195a
testl %eax, %eax
jne 0x46f3
jmp 0x4714
movl %ebp, %eax
movq %r14, %rdi
movl %ebx, %esi
callq 0x1080
movq (%r15), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x46e7
jmp 0x46c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: main
int main(void)
{
    TestThrow();
    CheckStack();

    TestReturn();
    CheckStack();

    TestMemory();
    CheckStack();

    TestNesting();
    CheckStack();

    TestAssert();
    CheckStack();

    TestValidate();
    CheckStack();

    TestCheck();
    CheckStack();

    TestRecursion();
    CheckStack();

    TestSignal();
    CheckStack();

    printf("\nREADY\n\n");
}

// Assembly:
pushq %rax
callq 0x47fd
callq 0x4723
callq 0x5197
callq 0x4723
callq 0x54a9
callq 0x4723
callq 0x73be
callq 0x4723
callq 0x5a14
callq 0x4723
leaq 0x61f6(%rip), %rdi      # 0xa981
callq 0x1070
movl 0x9aca(%rip), %esi      # 0xe260
leal 0x1(%rsi), %eax
movl %eax, 0x9ac1(%rip)      # 0xe260
leaq 0x5f14(%rip), %rdi      # 0xa6ba
xorl %eax, %eax
callq 0x1080
leaq 0x5f1b(%rip), %rdi      # 0xa6cf
movl $0x1b, %esi
xorl %eax, %eax
callq 0x1080
movl $0xa, %edi
callq 0x1050
callq 0x4723
callq 0x5fc3
callq 0x4723
callq 0x696f
callq 0x4723
callq 0x6b44
callq 0x4723
leaq 0x6089(%rip), %rdi      # 0xa87d
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: TestRecursion
static void TestRecursion(void)
{
    printf("\nRECURSION TESTS ---------------------------------------\n\n");

    printf("-->%2d: Hits a run-time exception after 10 levels?\n", testNum++);
    try
        recurse(10);
    catch (RuntimeException, e)
        printf("%s\n", e->getMessage());
    finally;
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4074(%rip), %rdi      # 0xa9f5
callq 0x1070
movl 0x78d4(%rip), %esi      # 0xe260
movl %esi, %eax
incl %eax
movl %eax, 0x78ca(%rip)      # 0xe260
leaq 0x3e20(%rip), %rdi      # 0xa7bd
xorl %eax, %eax
callq 0x1080
leaq 0x78c5(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x3a62(%rip), %rbx      # 0xa418
movl $0x2dc, %edx            # imm = 0x2DC
movq %rbx, %rsi
callq 0x157c
leaq 0x79ea(%rip), %r14      # 0xe3b4
leaq 0x776f(%rip), %r15      # 0xe140
movl $0x1, %r13d
movq (%rbp), %rdi
callq 0x1334
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2dc, %ecx            # imm = 0x2DC
callq 0x1bb0
testl %eax, %eax
je 0x6a17
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x6a17
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x6a79
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x2de, %r8d            # imm = 0x2DE
callq 0x1c49
testl %eax, %eax
je 0x6a91
movq (%r12), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x6a91
movq %r12, %rdi
movq %r15, %rsi
callq 0x1904
testl %eax, %eax
je 0x6a91
movq 0x8(%r12), %rdi
movl %r13d, %esi
callq 0x1f9d
movq (%r12), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
jmp 0x6a91
movq (%r12), %rax
movl $0x1, 0x1b8(%rax)
movl $0xa, %edi
callq 0x45c9
cmpl $0x0, 0x791c(%rip)      # 0xe3b4
je 0x69d7
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x6ad1
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x6ad1
movq (%r12), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x69d7
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x6b09
movq (%rbp), %rdi
callq 0x195a
testl %eax, %eax
je 0x6b2b
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x6b09
jmp 0x6ae7
movl $0xa, %edi
callq 0x1050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/meaning-matters[P]Except/Test.c
// Function: t5
static void t5(void)
{
    try
    {
        raise(SIGABRT);
    }
    catch (SegmentationFault, e);
    catch (IllegalInstruction, e);
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4d2e(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0xecb(%rip), %rbx       # 0xa418
movl $0xfe, %edx
movq %rbx, %rsi
callq 0x157c
leaq 0x4e6b(%rip), %r14      # 0xe3cc
leaq 0x4c58(%rip), %r15      # 0xe1c0
movl $0x1, %r12d
movq (%rbp), %rdi
callq 0x1334
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xfe, %ecx
callq 0x1bb0
testl %eax, %eax
je 0x95b2
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x95b2
addq $0x8, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
je 0x9644
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x102, %r8d            # imm = 0x102
callq 0x1c49
testl %eax, %eax
je 0x95e9
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x95e9
movq %r13, %rdi
movq %r15, %rsi
callq 0x1904
testl %eax, %eax
jne 0x9628
movq %r13, %rdi
movq %r14, %rsi
leaq 0x4baa(%rip), %rdx      # 0xe1a0
movq %rbx, %rcx
movl $0x103, %r8d            # imm = 0x103
callq 0x1c49
testl %eax, %eax
je 0x965c
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x965c
movq %r13, %rdi
leaq 0x4b81(%rip), %rsi      # 0xe1a0
callq 0x1904
testl %eax, %eax
je 0x965c
movq 0x8(%r13), %rdi
movl %r12d, %esi
callq 0x1f9d
movq (%r13), %rax
movl $0x2, 0x1b8(%rax)
jmp 0x965c
movq (%r13), %rax
movl $0x1, 0x1b8(%rax)
movl $0x6, %edi
callq 0x1030
cmpl $0x0, 0x4d69(%rip)      # 0xe3cc
je 0x956e
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x969c
addq $0xd0, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
jne 0x969c
movq (%r13), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x956e
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x96d4
movq (%rbp), %rdi
callq 0x195a
testl %eax, %eax
je 0x96f6
movq (%rbp), %rdi
callq 0x1334
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x96d4
jmp 0x96b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: deposit
void
deposit(Addr a, Word w)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		ww->core[a] = w;
	else if(IS_FF(a))
		ww->ffs[a & 037] = w;
	else
		ww->tss[a & 037] = w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x420a
movl 0xb3f4(%rip), %eax      # 0xf5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xb3cf(%rip), %rcx      # 0xf5d0
jae 0x421e
movw %si, 0x1c(%rcx,%rax,2)
jmp 0x4223
movzwl %di, %eax
leaq 0xb3bc(%rip), %rcx      # 0xf5d0
movw %si, 0x9c(%rcx,%rax,2)
jmp 0x4223
movw %si, 0x5c(%rcx,%rax,2)
popq %rbp
retq