// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/sam.c
// Function: sam_write1
int sam_write1(htsFile *fp, const sam_hdr_t *h, const bam1_t *b)
{
    switch (fp->format.format) {
    case binary_format:
        fp->format.category = sequence_data;
        fp->format.format = bam;
        /* fall-through */
    case bam:
        return bam_write_idx1(fp, h, b);

    case cram:
        return cram_put_bam_seq(fp->fp.cram, (bam1_t *)b);

    case text_format:
        fp->format.category = sequence_data;
        fp->format.format = sam;
        /* fall-through */
    case sam:
        if (fp->state) {
            SAM_state *fd = (SAM_state *)fp->state;

            // Threaded output
            if (!fd->h) {
                // NB: discard const.  We don't actually modify sam_hdr_t here,
                // just data pointed to by it (which is a bit weasely still),
                // but out cached pointer must be non-const as we want to
                // destroy it later on and sam_hdr_destroy takes non-const.
                //
                // We do this because some tools do sam_hdr_destroy; sam_close
                // while others do sam_close; sam_hdr_destroy.  The former is
                // an issue as we need the header still when flushing.
                fd->h = (sam_hdr_t *)h;
                fd->h->ref_count++;

                if (pthread_create(&fd->dispatcher, NULL, sam_dispatcher_write,
                                   fp) != 0)
                    return -2;
                fd->dispatcher_set = 1;
            }

            if (fd->h != h) {
                hts_log_error("SAM multi-threaded decoding does not support changing header");
                return -2;
            }

            // Find a suitable BAM array to copy to
            sp_bams *gb = fd->curr_bam;
            if (!gb) {
                pthread_mutex_lock(&fd->lines_m);
                if (fd->bams) {
                    fd->curr_bam = gb = fd->bams;
                    fd->bams = gb->next;
                    gb->next = NULL;
                    gb->nbams = 0;
                    gb->bam_mem = 0;
                    pthread_mutex_unlock(&fd->lines_m);
                } else {
                    pthread_mutex_unlock(&fd->lines_m);
                    if (!(gb = calloc(1, sizeof(*gb)))) return -1;
                    if (!(gb->bams = calloc(SAM_NBAM, sizeof(*gb->bams)))) {
                        free(gb);
                        return -1;
                    }
                    gb->nbams = 0;
                    gb->abams = SAM_NBAM;
                    gb->bam_mem = 0;
                    gb->fd = fd;
                    fd->curr_idx = 0;
                    fd->curr_bam = gb;
                }
            }

            if (!bam_copy1(&gb->bams[gb->nbams++], b))
                return -2;
            gb->bam_mem += b->l_data + sizeof(*b);

            // Dispatch if full
            if (gb->nbams == SAM_NBAM || gb->bam_mem > SAM_NBYTES*0.8) {
                gb->serial = fd->serial++;
                pthread_mutex_lock(&fd->command_m);
                if (fd->errcode != 0) {
                    pthread_mutex_unlock(&fd->command_m);
                    return -fd->errcode;
                }
                if (hts_tpool_dispatch3(fd->p, fd->q, sam_format_worker, gb,
                                        cleanup_sp_bams,
                                        cleanup_sp_lines, 0) < 0) {
                    pthread_mutex_unlock(&fd->command_m);
                    return -1;
                }
                pthread_mutex_unlock(&fd->command_m);
                fd->curr_bam = NULL;
            }

            // Dummy value as we don't know how long it really is.
            // We could track file sizes via a SAM_state field, but I don't think
            // it is necessary.
            return 1;
        } else {
            if (sam_format1(h, b, &fp->line) < 0) return -1;
            kputc('\n', &fp->line);
            if (fp->is_bgzf) {
                if (bgzf_flush_try(fp->fp.bgzf, fp->line.l) < 0)
                    return -1;
                if ( bgzf_write(fp->fp.bgzf, fp->line.s, fp->line.l) != fp->line.l ) return -1;
            } else {
                if ( hwrite(fp->fp.hfile, fp->line.s, fp->line.l) != fp->line.l ) return -1;
            }

            if (fp->idx) {
                if (fp->format.compression == bgzf) {
                    if (bgzf_idx_push(fp->fp.bgzf, fp->idx, b->core.tid, b->core.pos, bam_endpos(b),
                                      bgzf_tell(fp->fp.bgzf), !(b->core.flag&BAM_FUNMAP)) < 0) {
                        hts_log_error("Read '%s' with ref_name='%s', ref_length=%"PRIhts_pos", flags=%d, pos=%"PRIhts_pos" cannot be indexed",
                                bam_get_qname(b), sam_hdr_tid2name(h, b->core.tid), sam_hdr_tid2len(h, b->core.tid), b->core.flag, b->core.pos+1);
                        return -1;
                    }
                } else {
                    if (hts_idx_push(fp->idx, b->core.tid, b->core.pos, bam_endpos(b),
                                     bgzf_tell(fp->fp.bgzf), !(b->core.flag&BAM_FUNMAP)) < 0) {
                        hts_log_error("Read '%s' with ref_name='%s', ref_length=%"PRIhts_pos", flags=%d, pos=%"PRIhts_pos" cannot be indexed",
                                bam_get_qname(b), sam_hdr_tid2name(h, b->core.tid), sam_hdr_tid2len(h, b->core.tid), b->core.flag, b->core.pos+1);
                        return -1;
                    }
                }
            }

            return fp->line.l;
        }


    case fasta_format:
    case fastq_format: {
        fastq_state *x = (fastq_state *)fp->state;
        if (!x) {
            if (!(fp->state = fastq_state_init(fp->format.format
                                               == fastq_format ? '@' : '>')))
                return -2;
        }

        if (fastq_format1(fp->state, b, &fp->line) < 0)
            return -1;
        if (fp->is_bgzf) {
            if (bgzf_flush_try(fp->fp.bgzf, fp->line.l) < 0)
                return -1;
            if (bgzf_write(fp->fp.bgzf, fp->line.s, fp->line.l) != fp->line.l)
                return -1;
        } else {
            if (hwrite(fp->fp.hfile, fp->line.s, fp->line.l) != fp->line.l)
                return -1;
        }
        return fp->line.l;
    }

    default:
        errno = EBADF;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x10, %eax
ja 0x40005
movq -0x40(%rbp), %rax
leaq 0xb1d6e(%rip), %rcx     # 0xf1578
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x1, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x4c(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x40030
movl %eax, -0x4(%rbp)
jmp 0x40017
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x622e0
movl %eax, -0x4(%rbp)
jmp 0x40017
movq -0x10(%rbp), %rax
movl $0x1, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x3, 0x4c(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3fbb5
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3f8e9
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x948(%rip), %rdx       # 0x40210
callq 0x4910
cmpl $0x0, %eax
je 0x3f8de
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x40017
movq -0x28(%rbp), %rax
movl $0x1, 0x50(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x3f91c
movl $0x1, %edi
leaq 0xb2899(%rip), %rsi     # 0xf219b
leaq 0xb289d(%rip), %rdx     # 0xf21a6
movb $0x0, %al
callq 0x1b030
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x40017
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3fa4d
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x4730
movq -0x28(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3f9a2
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x4330
jmp 0x3fa4b
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x4330
movl $0x1, %edi
movl $0x30, %esi
callq 0x42f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3f9d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movl $0x3e8, %edi            # imm = 0x3E8
movl $0x50, %esi
callq 0x42f0
movq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x3fa06
movq -0x30(%rbp), %rdi
callq 0x45a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x3e8, 0x1c(%rax)      # imm = 0x3E8
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
jmp 0x3fa4d
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x18(%rcx)
cltq
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x33080
cmpq $0x0, %rax
jne 0x3fa88
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x40017
movq -0x20(%rbp), %rax
movslq 0x40(%rax), %rcx
addq $0x50, %rcx
movq -0x30(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
cmpl $0x3e8, 0x18(%rax)      # imm = 0x3E8
je 0x3faea
movq -0x30(%rbp), %rax
movq 0x20(%rax), %xmm0
movaps 0xafe43(%rip), %xmm1    # 0xef900
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xafe47(%rip), %xmm1    # 0xef910
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xb2070(%rip), %xmm1    # 0xf1b50
ucomisd %xmm1, %xmm0
jbe 0x3fba9
movq -0x28(%rbp), %rax
movl 0x74(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x74(%rax)
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0x4730
movq -0x28(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
je 0x3fb3b
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0x4330
movq -0x28(%rbp), %rcx
xorl %eax, %eax
subl 0xd4(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x40017
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x30(%rbp), %rcx
leaq -0x3f46(%rip), %rdx     # 0x3bc10
leaq 0xe63(%rip), %r8        # 0x409c0
leaq 0xe7c(%rip), %r9        # 0x409e0
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x4e2e0
cmpl $0x0, %eax
jge 0x3fb90
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0x4330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0x4330
movq -0x28(%rbp), %rax
movq $0x0, 0x68(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x40017
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
callq 0x3d960
cmpl $0x0, %eax
jge 0x3fbdb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0xa, %edi
callq 0x39080
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3fc59
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xff00
cmpl $0x0, %eax
jge 0x3fc24
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xffb0
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3fc57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fc8e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x38db0
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3fc8c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fc8e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x3fed8
movq -0x10(%rbp), %rax
cmpl $0x2, 0x54(%rax)
jne 0x3fdc0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33a20
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x4c(%rbp), %edx
movq -0x48(%rbp), %rcx
movq %rax, %r8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %r9
shlq $0x10, %r9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x10(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cltq
orq %rax, %r9
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0xbec0
cmpl $0x0, %eax
jge 0x3fdbb
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xdda00
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xdda90
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
movq %rax, %r9
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %r10d
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movl $0x1, %edi
leaq 0xb2403(%rip), %rsi     # 0xf219b
leaq 0xb2444(%rip), %rdx     # 0xf21e3
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fed6
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33a20
movq -0x88(%rbp), %rdi
movl -0x7c(%rbp), %esi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %r8
shlq $0x10, %r8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x10(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cltq
orq %rax, %r8
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x1f990
cmpl $0x0, %eax
jge 0x3fed4
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xdda00
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xdda90
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
movq %rax, %r9
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %r10d
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movl $0x1, %edi
leaq 0xb22ea(%rip), %rsi     # 0xf219b
leaq 0xb232b(%rip), %rdx     # 0xf21e3
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fed6
jmp 0x3fed8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x40017
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3ff33
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %ecx
movl $0x3e, %edi
movl $0x40, %eax
cmpl $0x11, %ecx
cmovel %eax, %edi
callq 0x3c630
movq -0x10(%rbp), %rcx
movq %rax, 0x40(%rcx)
cmpq $0x0, %rax
jne 0x3ff31
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x40017
jmp 0x3ff33
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
callq 0x3df90
cmpl $0x0, %eax
jge 0x3ff5d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3ffc6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xff00
cmpl $0x0, %eax
jge 0x3ff94
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xffb0
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3ffc4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fff8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x38db0
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3fff6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40017
jmp 0x3fff8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x40017
callq 0x4050
movl $0x9, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)