// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/src/search.cpp
// Function: search_helper(position*, move_line*, int, int, int, int, bool, bool, bool, search_stats*, unsigned long long*, undo*)
int32 search_helper(position *pos,move_line *parent_pv,
        int32 alpha,int32 beta,int32 depth,int32 ply,
        bool pv_node,bool incheck,bool null_ok,
        search_stats *stats,move *startp,undo *undo_stack) {

    assert(pos);
    assert(parent_pv);
    assert(ply > 0);
    assert(alpha < beta);
    assert(stats);

    stats->nodes++; // should include leaf nodes
    int32 orig_alpha = alpha;
    parent_pv->n=0;

    // leaf node?
    if (depth < 1 || ply >= MAX_PLY) {
        assert(!incheck);
        return qsearch(pos,alpha,beta,ply,0,incheck,stats,startp,undo_stack);
    }

    // time check
    if (!analysis_mode && nodes_last_time_check >= 50000) {
        if (milli_timer() >= stop_time) {
            abort_search = true;
            printd("# Aborting search depth=%d, ply=%d on time...\n",depth,ply);
            return 0;
        }
        nodes_last_time_check = 0;
    } else {
        nodes_last_time_check++;
    }

    // draw check.  Note: not doing insufficient material (too expensive?)
    if (is_draw_by_rep(pos,undo_stack) || is_draw_by_50(pos)) {
        return DRAWSCORE;
    }

    // check hash table for score and/or move
    uint64 hash_val = get_hash_entry(&htbl,pos->hash_key);
    if (hash_val != 0 && get_hash_entry_depth(hash_val) >= depth) {
        hash_entry_t hash_entry_type = get_hash_entry_type(hash_val);
        if (hash_entry_type==LOWER_BOUND) {
            if (get_hash_entry_score(hash_val) >= beta) {
                stats->fail_highs++;
                return beta;
            }
        } else if (hash_entry_type==UPPER_BOUND) {
            if (get_hash_entry_score(hash_val) <= alpha) {
                stats->fail_lows++;
                return alpha;
            }
        } else if (hash_entry_type==EXACT_SCORE) {
            stats->hash_exact_scores++;
            return get_hash_entry_score(hash_val);
        }
    }

    // Null Move
    // The idea here is that if my position is so good that, if by giving the opponent
    // an extra turn they can't raise their score to alpha, then when I actually do make
    // a move I will almost surely fail high.
    if (!pv_node && !incheck && null_ok && depth >= 3 && beta < INF && !is_zugzwang(pos)) {
        square_t ep_sq = apply_null_move(pos);
        int nullDepth = depth - 4; // R=3
        if (nullDepth < 1) { nullDepth = 1; } // don't drop into q-search
        int32 null_score = -search_helper(pos,parent_pv,-beta,-beta+1,nullDepth,ply,
                false,false,false,stats,startp,undo_stack);
        undo_null_move(pos,ep_sq);
        if (abort_search) {
            return 0;
        }
        if (null_score >= beta) {
            return beta;
        }
    }

    // get ready to search
    move_line pv; pv.n=0;
    uint32 moves_searched=0,moves_pruned=0;
    move best_mv = 0;
    move_order_dto mo_dto = build_move_order_dto(startp,
            (pv_node && stats->last_pv.n > ply ? stats->last_pv.mv[ply] : 0),
            get_hash_entry_move(hash_val),
            killer1[ply],killer2[ply],false);

    move *mp;
    while (next(pos,&mp,&mo_dto)) {
        assert(good_move(pos,*mp));
        apply_move(pos,*mp,undo_stack);
        if (in_check(pos,opposite_player(pos->player))) {
            undo_last_move(pos,undo_stack);
            continue;
        }

        if (pv_node && moves_searched==0) {
            stats->first_line_searched.mv[ply] = *mp;
            stats->first_line_searched.n = ply+1;
        }
        bool gives_check = in_check(pos,pos->player);
        int32 ext = extend(pos,*mp,gives_check);
        assert(ext >= 0 && ext <= 1);

        int32 score;

        // TODO: refactor so that pruning decision is here.  (So it will need to consider moves_searched.)

        // TODO: after that call a 'reduce()' function that returns an integer
        // Initially that would include the LMR tests.
        // Later add in the razoring tests: https://chessprogramming.wikispaces.com/Razoring

        // call to search should be depth-1+ext-red
        // Try PVS again!


        if (moves_searched==0) {
            score = -search_helper(pos,&pv,-beta,-alpha,depth-1+ext,ply+1,
                pv_node,gives_check,!pv_node,stats,mo_dto.endp,undo_stack);
        } else {

            // if this position is looking unpromising, just skip it
            if (prune(pos,*mp,incheck,gives_check,ext,alpha,beta,depth)) {
                undo_last_move(pos,undo_stack);
                stats->prunes++;
                moves_pruned++;
                continue;
            }

            // if we've searched enough moves and haven't gotten a fail high yet, this is likely
            // a fail-low node.  reduce the remaining moves.  if the score comes back above alpha,
            // then our assumption was wrong and we need to research at full depth.
            if (moves_searched >= 4 && depth >= 3
                    && !pv_node && !incheck && !gives_check && ext==0
                    && !is_capture(*mp) && !get_promopiece(*mp)
                    && *mp != mo_dto.killer1 && *mp != mo_dto.killer2)
            {
                score = -search_helper(pos,&pv,-(alpha+1),-alpha,depth-2,ply+1,
                    false,false,true,stats,mo_dto.endp,undo_stack);
            } else {
                score = alpha + 1; // ensure a full depth search
            }

            if (score > alpha) {
                // try a PVS search.  since this is not the PV node, our expectation is that it will not improve
                // alpha.  If it does, then we need to research with a full window to establish the real score.
                //score = -search_helper(pos,&pv,-(alpha+1),-alpha,depth-1+ext,ply+1,
                //  false,gives_check,(ext==0),stats,endp,undo_stack);

                //if (score > alpha && score < beta) {
                    score = -search_helper(pos,&pv,-beta,-alpha,depth-1+ext,ply+1,
                            false,gives_check,(ext==0),stats,mo_dto.endp,undo_stack);
                //}
            }
        }
        moves_searched++;

        // restore the position
        undo_last_move(pos,undo_stack);

        if (abort_search) {
            return 0;
        }

        if (score > alpha) {
            if (score >= beta) {
                store_hash_entry(&htbl,pos->hash_key,build_hash_val(LOWER_BOUND,depth,score,*mp));
                if (!is_capture(*mp) && !get_promopiece(*mp)) {
                    assert(get_move_score(mp)==0);
                    killer2[ply] = killer1[ply];
                    killer1[ply] = *mp;
                }
                return beta;
            }
            alpha = score;
            best_mv = *mp;
            update_parent_pv(parent_pv,&pv,*mp);
        }
    }

    assert(moves_searched+moves_pruned==num_moves(pos,true,true));
    assert(alpha >= orig_alpha);

    alpha = adjust_final_score_for_mates(pos,alpha,moves_searched,ply);

    hash_entry_t het = best_mv==0 ? UPPER_BOUND : EXACT_SCORE;
    store_hash_entry(&htbl,pos->hash_key,build_hash_val(het,depth,alpha,best_mv));


    return alpha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
testq %rdi, %rdi
je 0xbfe0
movq %rsi, %r13
testq %rsi, %rsi
je 0xbfff
movl %r9d, %ebx
testl %r9d, %r9d
jle 0xc01e
movl %ecx, %r14d
cmpl %ecx, %edx
jge 0xc03d
movq 0x428(%rsp), %r10
testq %r10, %r10
je 0xc05c
movl %r8d, %ebp
movq %rdi, %r15
incq 0x18(%r10)
movb 0x418(%rsp), %sil
movl $0x0, (%r13)
testl %r8d, %r8d
setg %al
cmpl $0x64, %ebx
setl %cl
testb %cl, %al
jne 0xb817
testb %sil, %sil
jne 0xc07b
subq $0x8, %rsp
movzbl %sil, %r9d
movq %r15, %rdi
movl %edx, %esi
movl %r14d, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
pushq 0x440(%rsp)
pushq 0x440(%rsp)
pushq %r10
callq 0xc1e1
addq $0x3f8, %rsp            # imm = 0x3F8
jmp 0xbfb6
movl %edx, 0x1c(%rsp)
movq 0x871116(%rip), %r12    # 0x87c938
cmpq $0xc350, %r12           # imm = 0xC350
setb %al
orb 0x87110e(%rip), %al     # 0x87c940
je 0xb839
incq %r12
jmp 0xb84d
callq 0xdf58
xorl %r12d, %r12d
cmpl 0x8710e9(%rip), %eax    # 0x87c930
jge 0xb8ef
movq %r12, 0x8710e4(%rip)    # 0x87c938
movq %r15, %rdi
movq 0x438(%rsp), %rsi
callq 0x4a11
xorl %r12d, %r12d
testb %al, %al
jne 0xbfac
movq %r15, %rdi
callq 0x4b4c
testb %al, %al
jne 0xbfac
movq 0x1b8(%r15), %rsi
leaq 0xec663(%rip), %rdi     # 0xf7ef0
callq 0x6263
testq %rax, %rax
movq %rbp, 0x38(%rsp)
movq %rax, 0x10(%rsp)
je 0xb90d
movq %rax, %rdi
callq 0x613c
cmpl %ebp, %eax
jl 0xb95d
movq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x6135
cmpl $0x3, %eax
je 0xb934
movb $0x1, %bpl
cmpl $0x2, %eax
je 0xb90f
cmpl $0x1, %eax
jne 0xb94f
movq %r12, %rdi
callq 0x6143
cmpl %r14d, %eax
jl 0xb94f
movq 0x428(%rsp), %rax
incq (%rax)
xorl %ebp, %ebp
movl %r14d, %r12d
jmp 0xb94f
movb $0x1, 0x87104b(%rip)    # 0x87c941
leaq 0x20791(%rip), %rdi     # 0x2c08e
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x652d
jmp 0xbfac
jmp 0xb95d
movq %r12, %rdi
callq 0x6143
cmpl 0x1c(%rsp), %eax
jg 0xb94f
movq 0x428(%rsp), %rax
incq 0x8(%rax)
xorl %ebp, %ebp
movl 0x1c(%rsp), %eax
movl %eax, %r12d
jmp 0xb94f
movq 0x428(%rsp), %rax
incq 0x10(%rax)
movq %r12, %rdi
callq 0x6143
movl %eax, %r12d
xorl %ebp, %ebp
jmp 0xb94f
testb %bpl, %bpl
movq 0x38(%rsp), %rbp
je 0xbfac
movb 0x410(%rsp), %al
orb 0x418(%rsp), %al
jne 0xba30
movb 0x420(%rsp), %al
cmpl $0x3, %ebp
setl %cl
xorb $0x1, %al
cmpl $0x30d40, %r14d         # imm = 0x30D40
setge %dl
orb %cl, %dl
orb %al, %dl
jne 0xba30
movq %r15, %rdi
callq 0xb17b
testb %al, %al
jne 0xba30
movq %r15, %rdi
callq 0x35be
movl %eax, 0x20(%rsp)
cmpl $0x6, %ebp
movl $0x5, %r8d
cmovgel %ebp, %r8d
addl $-0x4, %r8d
movl %r14d, %edx
negl %edx
movl $0x1, %ecx
subl %r14d, %ecx
xorl %eax, %eax
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %r9d
pushq 0x438(%rsp)
pushq 0x438(%rsp)
pushq 0x438(%rsp)
pushq %rax
pushq %rax
pushq %rax
callq 0xb760
addq $0x30, %rsp
movl %eax, %ebp
movq %r15, %rdi
movl 0x20(%rsp), %esi
callq 0x3643
movb 0x870f33(%rip), %al     # 0x87c941
negl %ebp
cmpl %r14d, %ebp
setge %cl
cmovgel %r14d, %r12d
orb %al, %cl
testb %al, %al
movl $0x0, %eax
cmovnel %eax, %r12d
testb $0x1, %cl
jne 0xbfac
movl $0x0, 0xb0(%rsp)
movq $0x0, 0x20(%rsp)
movl %ebx, %eax
movq %rax, 0x50(%rsp)
cmpb $0x0, 0x410(%rsp)
je 0xba6e
movq 0x428(%rsp), %rax
cmpl %ebx, 0x28(%rax)
jle 0xba6e
movq 0x50(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rbp
jmp 0xba70
xorl %ebp, %ebp
movq 0x10(%rsp), %rdi
callq 0x616d
leaq 0xec4cf(%rip), %rdx     # 0xf7f50
movq 0x50(%rsp), %rcx
movq (%rdx,%rcx,8), %r8
leaq 0xec7df(%rip), %rdx     # 0xf8270
movq (%rdx,%rcx,8), %r9
subq $0x8, %rsp
leaq 0x78(%rsp), %rdi
movq 0x438(%rsp), %rsi
movq %rbp, %rdx
movq %rax, %rcx
pushq $0x0
callq 0xb2db
addq $0x10, %rsp
movq %rsp, %rsi
movq %r15, %rdi
leaq 0x70(%rsp), %rdx
callq 0x8adc
testb %al, %al
je 0xbf01
leal 0x1(%rbx), %eax
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rax
leal -0x2(%rax), %ecx
movl %ecx, 0x64(%rsp)
movl %r14d, %ecx
negl %ecx
movl %ecx, 0x44(%rsp)
decl %eax
movq %rax, 0x68(%rsp)
movb 0x410(%rsp), %al
xorb $0x1, %al
movb %al, 0xf(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x438(%rsp), %rbp
movq (%rsp), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x9052
testb %al, %al
je 0xbfc1
movq (%rsp), %rax
movq (%rax), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x30e3
movl 0x138(%r15), %edi
callq 0xdfc4
movq %r15, %rdi
movl %eax, %esi
callq 0xaf39
testb %al, %al
je 0xbb91
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3341
movq %r15, %rdi
movq %rsp, %rsi
leaq 0x70(%rsp), %rdx
callq 0x8adc
testb %al, %al
jne 0xbb2a
jmp 0xbf1b
cmpl $0x0, 0x20(%rsp)
sete %al
andb 0x410(%rsp), %al
cmpb $0x1, %al
jne 0xbbca
movq (%rsp), %rax
movq (%rax), %rax
movq 0x428(%rsp), %rcx
movq 0x50(%rsp), %rdx
movq %rax, 0x358(%rcx,%rdx,8)
movl 0x28(%rsp), %eax
movl %eax, 0x350(%rcx)
movl 0x138(%r15), %esi
movq %r15, %rdi
callq 0xaf39
movq (%rsp), %rcx
movq (%rcx), %rsi
movb %al, 0xe(%rsp)
movzbl %al, %edx
movq %r15, %rdi
movq %rdx, 0x30(%rsp)
callq 0x5de4
cmpl $0x2, %eax
jae 0xc0d8
movl %eax, %r8d
cmpl $0x0, 0x20(%rsp)
je 0xbc6f
movq (%rsp), %rax
movq (%rax), %rsi
movb 0x418(%rsp), %al
movzbl %al, %edx
movq %r15, %rdi
movq 0x30(%rsp), %rcx
movq %r8, 0x48(%rsp)
movq 0x10(%rsp), %r9
movq 0x38(%rsp), %rbp
pushq %rbp
pushq %r14
callq 0xb1b4
addq $0x10, %rsp
testb %al, %al
je 0xbcba
movq %r15, %rdi
movq 0x438(%rsp), %rbp
movq %rbp, %rsi
callq 0x3341
movq 0x428(%rsp), %rax
incq 0x678(%rax)
incl 0x2c(%rsp)
movl $0x2, %eax
jmp 0xbde7
movq 0x10(%rsp), %rax
movl %eax, %ecx
negl %ecx
addl 0x68(%rsp), %r8d
movzbl 0xf(%rsp), %eax
movzbl 0x410(%rsp), %r10d
movq %r15, %rdi
leaq 0xb0(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x28(%rsp), %r9d
pushq %rbp
pushq 0xa8(%rsp)
pushq 0x438(%rsp)
pushq %rax
pushq 0x50(%rsp)
pushq %r10
jmp 0xbd74
cmpl $0x3, %ebp
setl %al
cmpl $0x4, 0x20(%rsp)
setb %cl
orb %al, %cl
movq 0x48(%rsp), %rsi
testl %esi, %esi
setne %al
movb 0xe(%rsp), %dl
orb %al, %dl
orb 0x410(%rsp), %cl
orb 0x418(%rsp), %cl
orb %dl, %cl
movq %rsi, %rdx
jne 0xbd1d
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x77df
movq 0x48(%rsp), %rdx
testb %al, %al
jne 0xbd1d
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x77cb
movq 0x48(%rsp), %rdx
testl %eax, %eax
je 0xbe85
movq 0x10(%rsp), %rcx
leal 0x1(%rcx), %eax
movq 0x438(%rsp), %rbp
cmpl %ecx, %eax
jle 0xbd7f
movq 0x10(%rsp), %rax
movl %eax, %ecx
negl %ecx
movq 0x68(%rsp), %rax
leal (%rax,%rdx), %r8d
xorl %eax, %eax
testl %edx, %edx
sete %al
movq %r15, %rdi
leaq 0xb0(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x28(%rsp), %r9d
pushq %rbp
pushq 0xa8(%rsp)
pushq 0x438(%rsp)
pushq %rax
pushq 0x50(%rsp)
pushq $0x0
callq 0xb760
addq $0x30, %rsp
negl %eax
movl %eax, 0x30(%rsp)
movq 0x20(%rsp), %rax
incl %eax
movq %rax, 0x20(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3341
cmpb $0x0, 0x870ba0(%rip)    # 0x87c941
je 0xbdad
xorl %r12d, %r12d
movl $0x1, %eax
jmp 0xbde7
xorl %eax, %eax
movl 0x30(%rsp), %r8d
cmpl 0x10(%rsp), %r8d
jle 0xbde7
cmpl %r14d, %r8d
jge 0xbdf4
movq (%rsp), %rax
movq (%rax), %rdx
movq %r13, %rdi
leaq 0xb0(%rsp), %rsi
movq %rdx, 0x58(%rsp)
callq 0xc116
movl 0x30(%rsp), %eax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
testb $0x1, %al
je 0xbb78
jmp 0xbfac
movq 0x1b8(%r15), %r12
movq (%rsp), %rax
movq (%rax), %rcx
movl $0x1, %edi
movq 0x38(%rsp), %rsi
movl %r8d, %edx
callq 0x5fa7
leaq 0xec0d5(%rip), %rdi     # 0xf7ef0
movq %r12, %rsi
movq %rax, %rdx
callq 0x62c0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x77df
testb %al, %al
jne 0xbe7d
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x77cb
testl %eax, %eax
jne 0xbe7d
movq (%rsp), %rdi
callq 0x77fd
testl %eax, %eax
jne 0xc0f7
movq 0x50(%rsp), %rcx
leaq 0xec0ed(%rip), %rdx     # 0xf7f50
movq (%rdx,%rcx,8), %rax
leaq 0xec402(%rip), %rsi     # 0xf8270
movq %rax, (%rsi,%rcx,8)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdx,%rcx,8)
movl %r14d, %r12d
jmp 0xbda6
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x88(%rsp), %rax
je 0xbd1d
cmpq 0x90(%rsp), %rax
je 0xbd1d
movq 0x10(%rsp), %rax
movl %eax, %edx
notl %edx
movl %eax, %ecx
negl %ecx
movq %r15, %rdi
leaq 0xb0(%rsp), %rsi
movl 0x64(%rsp), %r8d
movl 0x28(%rsp), %r9d
movq 0x438(%rsp), %rbp
pushq %rbp
pushq 0xa8(%rsp)
pushq 0x438(%rsp)
pushq $0x1
xorl %eax, %eax
pushq %rax
pushq %rax
callq 0xb760
movq 0x40(%rsp), %rcx
movq 0x78(%rsp), %rdx
addq $0x30, %rsp
negl %eax
jmp 0xbd2d
movl $0x0, 0x2c(%rsp)
movq $0x0, 0x58(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %ebp
addl 0x20(%rsp), %ebp
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xe78d
cmpl %eax, %ebp
jne 0xc09a
movq 0x10(%rsp), %r12
cmpl 0x1c(%rsp), %r12d
movq 0x38(%rsp), %r14
jl 0xc0b9
cmpl $0x0, 0x20(%rsp)
jne 0xbf77
movl 0x138(%r15), %esi
movq %r15, %rdi
callq 0xaf39
addl $0xffff0001, %ebx       # imm = 0xFFFF0001
xorl %r12d, %r12d
testb %al, %al
cmovnel %ebx, %r12d
movq 0x58(%rsp), %rcx
cmpq $0x1, %rcx
movl $0x3, %edi
sbbl $0x0, %edi
movq 0x1b8(%r15), %rbx
movl %r14d, %esi
movl %r12d, %edx
callq 0x5fa7
leaq 0xebf4f(%rip), %rdi     # 0xf7ef0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x62c0
movl %r12d, %eax
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2001a(%rip), %rdi     # 0x2bfe2
leaq 0x1ff17(%rip), %rsi     # 0x2bee6
leaq 0x2001f(%rip), %rcx     # 0x2bff5
movl $0xdd, %edx
callq 0x20d0
leaq 0x1d55a(%rip), %rdi     # 0x29541
leaq 0x1fef8(%rip), %rsi     # 0x2bee6
leaq 0x20000(%rip), %rcx     # 0x2bff5
movl $0x8a, %edx
callq 0x20d0
leaq 0x1ffb5(%rip), %rdi     # 0x2bfbb
leaq 0x1fed9(%rip), %rsi     # 0x2bee6
leaq 0x1ffe1(%rip), %rcx     # 0x2bff5
movl $0x8b, %edx
callq 0x20d0
leaq 0x2004b(%rip), %rdi     # 0x2c070
leaq 0x1feba(%rip), %rsi     # 0x2bee6
leaq 0x1ffc2(%rip), %rcx     # 0x2bff5
movl $0x8c, %edx
callq 0x20d0
leaq 0x20034(%rip), %rdi     # 0x2c078
leaq 0x1fe9b(%rip), %rsi     # 0x2bee6
leaq 0x1ffa3(%rip), %rcx     # 0x2bff5
movl $0x8d, %edx
callq 0x20d0
leaq 0x1ff62(%rip), %rdi     # 0x2bfc5
leaq 0x1fe7c(%rip), %rsi     # 0x2bee6
leaq 0x1ff84(%rip), %rcx     # 0x2bff5
movl $0x8e, %edx
callq 0x20d0
leaq 0x20003(%rip), %rdi     # 0x2c085
leaq 0x1fe5d(%rip), %rsi     # 0x2bee6
leaq 0x1ff65(%rip), %rcx     # 0x2bff5
movl $0x96, %edx
callq 0x20d0
leaq 0x20047(%rip), %rdi     # 0x2c0e8
leaq 0x1fe3e(%rip), %rsi     # 0x2bee6
leaq 0x1ff46(%rip), %rcx     # 0x2bff5
movl $0x138, %edx            # imm = 0x138
callq 0x20d0
leaq 0x2005e(%rip), %rdi     # 0x2c11e
leaq 0x1fe1f(%rip), %rsi     # 0x2bee6
leaq 0x1ff27(%rip), %rcx     # 0x2bff5
movl $0x139, %edx            # imm = 0x139
callq 0x20d0
leaq 0x1ffde(%rip), %rdi     # 0x2c0bd
leaq 0x1fe00(%rip), %rsi     # 0x2bee6
leaq 0x1ff08(%rip), %rcx     # 0x2bff5
movl $0xea, %edx
callq 0x20d0
leaq 0x1ffd4(%rip), %rdi     # 0x2c0d2
leaq 0x1fde1(%rip), %rsi     # 0x2bee6
leaq 0x1fee9(%rip), %rcx     # 0x2bff5
movl $0x12c, %edx            # imm = 0x12C
callq 0x20d0