// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/vlen.c
// Function: vflen
int vflen(char *fmt, va_list ap)
{
    int len = 0;
    char *cp, c;
    long long l;
    int i;
    double d; 

    /*
     * This code modifies 'ap', but we do not know if va_list is a structure
     * or a pointer to an array so we do not know if it is a local variable
     * or not.
     * C99 gets around this by defining va_copy() to make copies of ap, but
     * this does not exist on all systems.
     * For now, I just assume that when va_list is a pointer the system also
     * provides a va_copy macro to work around this problem. The only system
     * I have seen needing this so far was Linux on AMD64.
     */
#if defined(HAVE_VA_COPY)
    va_list ap_local;
    va_copy(ap_local, ap);
#    define ap ap_local
#endif

    for(cp = fmt; *cp; cp++) {
	switch(*cp) {

	/* A format specifier */
	case '%': {
	    char *endp;
	    long conv_len1=0, conv_len2=0, conv_len=0;
	    signed int arg_size;

	    /* Firstly, strip the modifier flags (+-#0 and [space]) */
	    for(; (c=*++cp);) {
		if ('#' == c)
		    len+=2; /* Worst case of "0x" */
		else if ('-' == c || '+' == c || ' ' == c)
		    len++;
		else
		    break;
	    }

	    /* Width specifier */
	    l = strtol(cp, &endp, 10);
	    if (endp != cp) {
		cp = endp;
		conv_len = conv_len1 = l;
	    } else if (*cp == '*') {
		conv_len = conv_len1 = (int)va_arg(ap, int);
		cp++;
	    }

	    /* Precision specifier */
	    if ('.' == *cp) {
		cp++;
		conv_len2 = strtol(cp, &endp, 10);
		if (endp != cp) {
		    cp = endp;
		} else if (*cp == '*') {
		    conv_len2 = (int)va_arg(ap, int);
		    cp++;
		}
		conv_len = MAX(conv_len1, conv_len2);
	    }

	    /* Short/long identifier */
	    if ('h' == *cp) {
		arg_size = -1; /* short */
		cp++;
	    } else if ('l' == *cp) {
		arg_size = 1; /* long */
		cp++;
		if ('l' == *cp) {
		    arg_size = 2; /* long long */
		    cp++;
		}
	    } else {
		arg_size = 0; /* int */
	    }

	    /* The actual type */
	    switch (*cp) {
	    case '%':
		/*
		 * Not real ANSI I suspect, but we'll allow for the
		 * completely daft "%10%" example.
		 */
		len += MAX(conv_len1, 1);
		break;

	    case 'd':
	    case 'i':
	    case 'u':
	    case 'a':
	    case 'x':
	    case 'X':
		/* Remember: char and short are sent as int on the stack */
		if (arg_size == -1)
		    l = (long)va_arg(ap, int);
		else if (arg_size == 1)
		    l = va_arg(ap, long); 
		else if (arg_size == 2)
		    l = va_arg(ap, long long); 
		else 
		    l = (long)va_arg(ap, int);

		DEBUG_printf("%d", l);

		/*
		 * No number can be more than 24 characters so we'll take
		 * the max of conv_len and 24 (23 is len(2^64) in octal).
		 * All that work above and we then go and estimate ;-),
		 * but it's needed incase someone does %500d.
		 */
		len += MAX(conv_len, 23);
		break;

	    case 'c':
		i = va_arg(ap, int);
		DEBUG_printf("%c", i);
		/*
		 * Note that %10c and %.10c act differently.
		 * Besides, I think precision is not really allowed for %c.
		 */
		len += MAX(conv_len1, i>=0x80 ?MB_CUR_MAX :1);
		break;

	    case 'f':
		d = va_arg(ap, double);
		DEBUG_printf("%f", d);
		/*
		 * Maybe "Inf" or "NaN", but we'll not worry about that.
		 * Again, err on side of caution and take max of conv_len
		 * and max length of a double. The worst case I can
		 * think of is 317 characters (-1[308 zeros].000000)
		 * without using precision codes. That's horrid. I
		 * cheat and either use 317 or 15 depending on how
		 * large the number is as I reckon 99% of floats
		 * aren't that long.
		 */
		l = (ABS(d) > 1000000) ? 317 : 15;
		l = MAX(l, conv_len1 + 2);
		if (conv_len2) l += conv_len2 - 6;
		len += l;
		break;

	    case 'e':
	    case 'E':
	    case 'g':
	    case 'G':
		d = va_arg(ap, double);
		DEBUG_printf("%g", d);
		/*
		 * Maybe "Inf" or "NaN", but we'll not worry about that
		 * Again, err on side of caution and take max of conv_len
		 * and max length of a double (which defaults to only
		 * '-' + 6 + '.' + 'E[+-]xxx' == 13.
		 */
		len += MAX(conv_len, 13);
		break;

	    case 'p':
		l = (long)va_arg(ap, void *);
		/*
		 * Max pointer is 64bits == 16 chars (on alpha),
		 * == 20 with + "0x".
		 */
		DEBUG_printf("%p", (void *)l);
		len += MAX(conv_len, 20);
		break;

	    case 'n':
		/* produces no output */
		break;

	    case 's': {
		char *s = (char *)va_arg(ap, char *);
		DEBUG_printf("%s", s);

		if (!conv_len2) {
		    len += MAX(conv_len, (int)strlen(s));
		} else {
		    len += conv_len;
		}
		break;
	    }

	    default:
		/* wchar_t types of 'C' and 'S' aren't supported */
		DEBUG_printf("Arg is %c\n", *cp);
	    }
	    
	}

	case '\0':
	    break;

	default:
	    DEBUG_printf("%c", *cp);
	    len++;
	}
    }

    va_end(ap);

    return len+1; /* one for the null character */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x99bf5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x74(%rbp)
testl %eax, %eax
je 0x99bd7
jmp 0x99263
movl -0x74(%rbp), %eax
subl $0x25, %eax
jne 0x99bd9
jmp 0x99271
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb 0x1(%rax), %al
movb %al, -0x21(%rbp)
cmpb $0x0, %al
je 0x992f2
movsbl -0x21(%rbp), %ecx
movl $0x23, %eax
cmpl %ecx, %eax
jne 0x992ba
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x992f0
movsbl -0x21(%rbp), %ecx
movl $0x2d, %eax
cmpl %ecx, %eax
je 0x992e1
movsbl -0x21(%rbp), %ecx
movl $0x2b, %eax
cmpl %ecx, %eax
je 0x992e1
movsbl -0x21(%rbp), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
jne 0x992ec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x992ee
jmp 0x992f2
jmp 0x992f0
jmp 0x99289
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0xa, %edx
callq 0x6a50
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x99328
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x60(%rbp)
jmp 0x9939c
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x9939a
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl (%rax), %eax
movl %eax, -0x78(%rbp)
cmpl $0x28, %eax
ja 0x99362
movq -0x80(%rbp), %rcx
movl -0x78(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x88(%rbp)
jmp 0x9937c
movq -0x80(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9939c
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x2e, %eax
cmpl %ecx, %eax
jne 0x99492
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0xa, %edx
callq 0x6a50
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x993e6
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x99465
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x99463
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
cmpl $0x28, %eax
ja 0x9942c
movq -0x98(%rbp), %rcx
movl -0x8c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xa0(%rbp)
jmp 0x99449
movq -0x98(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x99465
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jle 0x9947c
movq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x99487
movq -0x58(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x68, %eax
cmpl %ecx, %eax
jne 0x994b7
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x99508
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x6c, %eax
cmpl %ecx, %eax
jne 0x994ff
movl $0x1, -0x64(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x6c, %eax
cmpl %ecx, %eax
jne 0x994fd
movl $0x2, -0x64(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x99506
movl $0x0, -0x64(%rbp)
jmp 0x99508
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
addl $-0x25, %eax
movl %eax, %ecx
movq %rcx, -0xb0(%rbp)
subl $0x53, %eax
ja 0x99bd3
movq -0xb0(%rbp), %rax
leaq 0x4a446(%rip), %rcx     # 0xe3978
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x1, -0x50(%rbp)
jle 0x9954f
movq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
jmp 0x9955d
movl $0x1, %eax
movq %rax, -0xb8(%rbp)
jmp 0x9955d
movq -0xb8(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
cmpl $-0x1, -0x64(%rbp)
jne 0x995e3
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
cmpl $0x28, %eax
ja 0x995b3
movq -0xc8(%rbp), %rcx
movl -0xbc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xd0(%rbp)
jmp 0x995d0
movq -0xc8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x99729
cmpl $0x1, -0x64(%rbp)
jne 0x99653
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl (%rax), %eax
movl %eax, -0xd4(%rbp)
cmpl $0x28, %eax
ja 0x99623
movq -0xe0(%rbp), %rcx
movl -0xd4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xe8(%rbp)
jmp 0x99640
movq -0xe0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x99727
cmpl $0x2, -0x64(%rbp)
jne 0x996c0
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl (%rax), %eax
movl %eax, -0xec(%rbp)
cmpl $0x28, %eax
ja 0x99693
movq -0xf8(%rbp), %rcx
movl -0xec(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x100(%rbp)
jmp 0x996b0
movq -0xf8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x99725
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movl (%rax), %eax
movl %eax, -0x104(%rbp)
cmpl $0x28, %eax
ja 0x996fa
movq -0x110(%rbp), %rcx
movl -0x104(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x118(%rbp)
jmp 0x99717
movq -0x110(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x99727
jmp 0x99729
cmpq $0x17, -0x60(%rbp)
jle 0x9973d
movq -0x60(%rbp), %rax
movq %rax, -0x120(%rbp)
jmp 0x9974b
movl $0x17, %eax
movq %rax, -0x120(%rbp)
jmp 0x9974b
movq -0x120(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movl (%rax), %eax
movl %eax, -0x124(%rbp)
cmpl $0x28, %eax
ja 0x9979b
movq -0x130(%rbp), %rcx
movl -0x124(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x138(%rbp)
jmp 0x997b8
movq -0x130(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpl $0x80, -0x34(%rbp)
jl 0x997e6
callq 0x6100
movq %rax, -0x148(%rbp)
jmp 0x997f4
movl $0x1, %eax
movq %rax, -0x148(%rbp)
jmp 0x997f4
movq -0x140(%rbp), %rax
movq -0x148(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x99814
movq -0x50(%rbp), %rax
movq %rax, -0x150(%rbp)
jmp 0x99847
cmpl $0x80, -0x34(%rbp)
jl 0x9982b
callq 0x6100
movq %rax, -0x158(%rbp)
jmp 0x99839
movl $0x1, %eax
movq %rax, -0x158(%rbp)
jmp 0x99839
movq -0x158(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x168(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x15c(%rbp)
cmpl $0xa0, %eax
ja 0x998af
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movq -0x170(%rbp), %rsi
movslq %edx, %rax
addq 0x10(%rsi), %rax
addl $0x10, %edx
movl %edx, (%rcx)
movq %rax, -0x178(%rbp)
jmp 0x998cc
movq -0x170(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x998f9
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x180(%rbp)
jmp 0x9991d
movsd -0x40(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x180(%rbp)
movsd -0x180(%rbp), %xmm0
movsd 0x4a043(%rip), %xmm1    # 0xe3970
movl $0xf, %eax
movl $0x13d, %ecx            # imm = 0x13D
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jle 0x99962
movq -0x30(%rbp), %rax
movq %rax, -0x188(%rbp)
jmp 0x99971
movq -0x50(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x188(%rbp)
movq -0x188(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x99993
movq -0x58(%rbp), %rax
subq $0x6, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x198(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x18c(%rbp)
cmpl $0xa0, %eax
ja 0x999f8
movq -0x198(%rbp), %rcx
movl -0x18c(%rbp), %edx
movq -0x1a0(%rbp), %rsi
movslq %edx, %rax
addq 0x10(%rsi), %rax
addl $0x10, %edx
movl %edx, (%rcx)
movq %rax, -0x1a8(%rbp)
jmp 0x99a15
movq -0x1a0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
cmpq $0xd, -0x60(%rbp)
jle 0x99a39
movq -0x60(%rbp), %rax
movq %rax, -0x1b0(%rbp)
jmp 0x99a47
movl $0xd, %eax
movq %rax, -0x1b0(%rbp)
jmp 0x99a47
movq -0x1b0(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl (%rax), %eax
movl %eax, -0x1b4(%rbp)
cmpl $0x28, %eax
ja 0x99a97
movq -0x1c0(%rbp), %rcx
movl -0x1b4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1c8(%rbp)
jmp 0x99ab4
movq -0x1c0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x14, -0x60(%rbp)
jle 0x99ad6
movq -0x60(%rbp), %rax
movq %rax, -0x1d0(%rbp)
jmp 0x99ae4
movl $0x14, %eax
movq %rax, -0x1d0(%rbp)
jmp 0x99ae4
movq -0x1d0(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
jmp 0x99bd5
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl (%rax), %eax
movl %eax, -0x1d4(%rbp)
cmpl $0x28, %eax
ja 0x99b39
movq -0x1e0(%rbp), %rcx
movl -0x1d4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1e8(%rbp)
jmp 0x99b56
movq -0x1e0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x99bc3
movq -0x60(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq -0x70(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movq -0x1f0(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x99b9e
movq -0x60(%rbp), %rax
movq %rax, -0x1f8(%rbp)
jmp 0x99bb0
movq -0x70(%rbp), %rdi
callq 0x62c0
cltq
movq %rax, -0x1f8(%rbp)
movq -0x1f8(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd1
movq -0x60(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x99bd5
jmp 0x99bd5
jmp 0x99bd7
jmp 0x99be2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x99be4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x99242
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %eax
addl $0x1, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopl (%rax,%rax)