// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: adoption_agency_algorithm
static bool adoption_agency_algorithm (
  GumboParser* parser,
  GumboToken* token,
  GumboTag subject
) {
  GumboParserState* state = parser->_parser_state;
  gumbo_debug("Entering adoption agency algorithm.\n");
  // Step 1.
  GumboNode* current_node = get_current_node(parser);
  if (
    current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML
    && current_node->v.element.tag == subject
    && -1 == gumbo_vector_index_of (
      &state->_active_formatting_elements,
      current_node
    )
  ) {
    pop_current_node(parser);
    return false;
  }
  // Steps 2-4 & 20:
  for (unsigned int i = 0; i < 8; ++i) {
    // Step 5.
    GumboNode* formatting_node = NULL;
    int formatting_node_in_open_elements = -1;
    for (int j = state->_active_formatting_elements.length; --j >= 0;) {
      GumboNode* current_node = state->_active_formatting_elements.data[j];
      if (current_node == &kActiveFormattingScopeMarker) {
        gumbo_debug("Broke on scope marker; aborting.\n");
        // Last scope marker; abort the algorithm.
        return false;
      }
      if (node_html_tag_is(current_node, subject)) {
        // Found it.
        formatting_node = current_node;
        formatting_node_in_open_elements = gumbo_vector_index_of (
          &state->_open_elements,
          formatting_node
        );
        gumbo_debug (
          "Formatting element of tag %s at %d.\n",
          gumbo_normalized_tagname(subject),
          formatting_node_in_open_elements
        );
        break;
      }
    }
    if (!formatting_node) {
      // No matching tag; not a parse error outright, but fall through to the
      // "any other end tag" clause (which may potentially add a parse error,
      // but not always).
      gumbo_debug("No active formatting elements; aborting.\n");
      return false;
    }

    // Step 6
    if (formatting_node_in_open_elements == -1) {
      gumbo_debug("Formatting node not on stack of open elements.\n");
      parser_add_parse_error(parser, token);
      gumbo_vector_remove (
        formatting_node,
        &state->_active_formatting_elements
      );
      return false;
    }

    // Step 7
    if (!has_an_element_in_scope(parser, formatting_node->v.element.tag)) {
      parser_add_parse_error(parser, token);
      gumbo_debug("Element not in scope.\n");
      return false;
    }

    // Step 8
    if (formatting_node != get_current_node(parser)) {
      parser_add_parse_error(parser, token);  // But continue onwards.
    }
    assert(formatting_node);
    assert(!node_html_tag_is(formatting_node, GUMBO_TAG_HTML));
    assert(!node_html_tag_is(formatting_node, GUMBO_TAG_BODY));

    // Step 9 & 10
    GumboNode* furthest_block = NULL;
    for (
      unsigned int j = formatting_node_in_open_elements;
      j < state->_open_elements.length;
      ++j
    ) {
      assert(j > 0);
      GumboNode* current = state->_open_elements.data[j];
      if (is_special_node(current)) {
        // Step 9.
        furthest_block = current;
        break;
      }
    }
    if (!furthest_block) {
      // Step 10.
      while (get_current_node(parser) != formatting_node) {
        pop_current_node(parser);
      }
      // And the formatting element itself.
      pop_current_node(parser);
      gumbo_vector_remove (
        formatting_node,
        &state->_active_formatting_elements
      );
      return false;
    }
    assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
    assert(furthest_block);

    // Step 11.
    // Elements may be moved and reparented by this algorithm, so
    // common_ancestor is not necessarily the same as formatting_node->parent.
    GumboNode* common_ancestor = state->_open_elements.data [
      gumbo_vector_index_of(&state->_open_elements, formatting_node) - 1
    ];
    gumbo_debug (
      "Common ancestor tag = %s, furthest block tag = %s.\n",
      gumbo_normalized_tagname(common_ancestor->v.element.tag),
      gumbo_normalized_tagname(furthest_block->v.element.tag)
    );

    // Step 12.
    int bookmark = 1 + gumbo_vector_index_of (
      &state->_active_formatting_elements,
      formatting_node
    );
    gumbo_debug("Bookmark at %d.\n", bookmark);
    // Step 13.
    GumboNode* node = furthest_block;
    GumboNode* last_node = furthest_block;
    // Must be stored explicitly, in case node is removed from the stack of open
    // elements, to handle step 9.4.
    int saved_node_index = gumbo_vector_index_of(&state->_open_elements, node);
    assert(saved_node_index > 0);
    // Step 13.1.
    for (int j = 0;;) {
      // Step 13.2.
      ++j;
      // Step 13.3.
      int node_index = gumbo_vector_index_of(&state->_open_elements, node);
      gumbo_debug (
        "Current index: %d, last index: %d.\n",
        node_index,
        saved_node_index
      );
      if (node_index == -1) {
        node_index = saved_node_index;
      }
      saved_node_index = --node_index;
      assert(node_index > 0);
      assert((unsigned int) node_index < state->_open_elements.capacity);
      node = state->_open_elements.data[node_index];
      assert(node->parent);
      if (node == formatting_node) {
        // Step 13.4.
        break;
      }
      int formatting_index = gumbo_vector_index_of (
        &state->_active_formatting_elements,
        node
      );
      if (j > 3 && formatting_index != -1) {
        // Step 13.5.
        gumbo_debug("Removing formatting element at %d.\n", formatting_index);
        gumbo_vector_remove_at (
          formatting_index,
          &state->_active_formatting_elements
        );
        // Removing the element shifts all indices over by one, so we may need
        // to move the bookmark.
        if (formatting_index < bookmark) {
          --bookmark;
          gumbo_debug("Moving bookmark to %d.\n", bookmark);
        }
        continue;
      }
      if (formatting_index == -1) {
        // Step 13.6.
        gumbo_vector_remove_at(node_index, &state->_open_elements);
        continue;
      }
      // Step 13.7.
      // "common ancestor as the intended parent" doesn't actually mean insert
      // it into the common ancestor; that happens below.
      node = clone_node(node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
      assert(formatting_index >= 0);
      state->_active_formatting_elements.data[formatting_index] = node;
      assert(node_index >= 0);
      state->_open_elements.data[node_index] = node;
      // Step 13.8.
      if (last_node == furthest_block) {
        bookmark = formatting_index + 1;
        gumbo_debug("Bookmark moved to %d.\n", bookmark);
        assert((unsigned int) bookmark <= state->_active_formatting_elements.length);
      }
      // Step 13.9.
      last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
      remove_from_parent(last_node);
      append_node(node, last_node);
      // Step 13.10.
      last_node = node;
    }  // Step 13.11.

    // Step 14.
    gumbo_debug (
      "Removing %s node from parent ",
      gumbo_normalized_tagname(last_node->v.element.tag)
    );
    remove_from_parent(last_node);
    last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
    InsertionLocation location = get_appropriate_insertion_location (
      parser,
      common_ancestor
    );
    gumbo_debug (
      "and inserting it into %s.\n",
      gumbo_normalized_tagname(location.target->v.element.tag)
    );
    insert_node(last_node, location);

    // Step 15.
    GumboNode* new_formatting_node = clone_node (
      formatting_node,
      GUMBO_INSERTION_ADOPTION_AGENCY_CLONED
    );
    formatting_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;

    // Step 16. Instead of appending nodes one-by-one, we swap the children
    // vector of furthest_block with the empty children of new_formatting_node,
    // reducing memory traffic and allocations. We still have to reset their
    // parent pointers, though.
    GumboVector temp = new_formatting_node->v.element.children;
    new_formatting_node->v.element.children = furthest_block->v.element.children;
    furthest_block->v.element.children = temp;

    temp = new_formatting_node->v.element.children;
    for (unsigned int i = 0; i < temp.length; ++i) {
      GumboNode* child = temp.data[i];
      child->parent = new_formatting_node;
    }

    // Step 17.
    append_node(furthest_block, new_formatting_node);

    // Step 18.
    // If the formatting node was before the bookmark, it may shift over all
    // indices after it, so we need to explicitly find the index and possibly
    // adjust the bookmark.
    int formatting_node_index = gumbo_vector_index_of (
      &state->_active_formatting_elements,
      formatting_node
    );
    assert(formatting_node_index != -1);
    if (formatting_node_index < bookmark) {
      gumbo_debug (
        "Formatting node at %d is before bookmark at %d; decrementing.\n",
        formatting_node_index, bookmark
      );
      --bookmark;
    }
    gumbo_vector_remove_at (
      formatting_node_index,
      &state->_active_formatting_elements
    );
    assert(bookmark >= 0);
    assert((unsigned int) bookmark <= state->_active_formatting_elements.length);
    gumbo_vector_insert_at (
      new_formatting_node,
      bookmark,
      &state->_active_formatting_elements
    );

    // Step 19.
    gumbo_vector_remove(formatting_node, &state->_open_elements);
    int insert_at = 1 + gumbo_vector_index_of (
      &state->_open_elements,
      furthest_block
    );
    assert(insert_at >= 0);
    assert((unsigned int) insert_at <= state->_open_elements.length);
    gumbo_vector_insert_at (
      new_formatting_node,
      insert_at,
      &state->_open_elements
    );
  }  // Step 20.
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %r13d
movq %rsi, 0x48(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %r14
callq 0x8107
cmpl $0x0, 0x2c(%rax)
jne 0xc30b
cmpl %r13d, 0x28(%rax)
jne 0xc30b
leaq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x7fbe
cmpl $-0x1, %eax
je 0xc870
movq %rbx, 0x30(%rsp)
leaq 0x18(%r14), %r15
leaq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
movq %r14, 0x8(%rsp)
movl 0x20(%r14), %r14d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rsp)
testl %r14d, %r14d
jle 0xc3a9
movq (%r15), %rax
movq -0x8(%rax,%r14,8), %r12
xorl %ebp, %ebp
leaq 0xf6ac(%rip), %rax      # 0x1ba08
cmpq %rax, %r12
je 0xc399
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x8b69
movb $0x1, %cl
testb %al, %al
je 0xc3a0
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x7fbe
movl %eax, %ebx
movl %r13d, %edi
callq 0x7a30
movl $0x5, %ebp
xorl %ecx, %ecx
movq %r12, 0x10(%rsp)
jmp 0xc3a0
movl $0x1, %ebp
xorl %ecx, %ecx
decq %r14
testb %cl, %cl
jne 0xc346
jmp 0xc3ae
movl $0x5, %ebp
cmpl $0x5, %ebp
jne 0xc82e
movl $0x1, %ebp
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0xc82e
cmpl $-0x1, %ebx
je 0xc497
movl 0x28(%r14), %eax
movl %eax, 0x5c(%rsp)
movq %r14, %r12
movq 0x30(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
leaq 0x5c(%rsp), %rdx
xorl %ecx, %ecx
leaq 0x10177(%rip), %r8      # 0x1c570
callq 0xbc6a
testb %al, %al
je 0xc4ab
movq %r14, %rdi
callq 0x8107
cmpq %rax, %r12
je 0xc420
movq %r14, %rdi
movq 0x48(%rsp), %rsi
callq 0x8171
movq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b69
testb %al, %al
jne 0xc95c
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x8b69
testb %al, %al
jne 0xc93d
movq 0x8(%rsp), %rax
cmpl 0x10(%rax), %ebx
jae 0xc4bd
movl %ebx, %r14d
xorl %r12d, %r12d
testq %r14, %r14
je 0xc8e0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rbx
movq %rbx, %rdi
callq 0xcc8d
testb %al, %al
cmovneq %rbx, %r12
jne 0xc4c0
incq %r14
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
cmpq %rax, %r14
jb 0xc460
jmp 0xc4c0
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x8171
jmp 0xc823
movq %r14, %rdi
movq 0x48(%rsp), %rsi
callq 0x8171
jmp 0xc82e
xorl %r12d, %r12d
testq %r12, %r12
movq 0x30(%rsp), %rbx
je 0xc7f7
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b69
testb %al, %al
jne 0xc97b
movq %r15, 0x28(%rsp)
movq 0x18(%rsp), %r14
movq (%r14), %rbx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x7fbe
cltq
movq -0x8(%rbx,%rax,8), %rax
movq %rax, 0x70(%rsp)
movl 0x28(%rax), %edi
callq 0x7a30
movl 0x28(%r12), %edi
callq 0x7a30
movq %r14, %rdi
movq %r12, %rsi
callq 0x7fbe
testl %eax, %eax
movq 0x8(%rsp), %rbp
jle 0xc99a
movl %eax, %ebx
movq %r14, %rdi
movq %r12, 0x38(%rsp)
movq %r12, %rsi
callq 0x7fbe
cmpl $-0x1, %eax
cmovnel %eax, %ebx
cmpl $0x2, %ebx
jl 0xc883
movq 0x38(%rsp), %r15
leaq 0x18(%r15), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7fbe
incl %eax
movl %eax, 0x24(%rsp)
xorl %r14d, %r14d
movq %r15, 0x40(%rsp)
decl %ebx
cmpl 0x14(%rbp), %ebx
jae 0xc8c1
movl %r13d, %r15d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %ebx, %r13d
movq (%rax,%r13,8), %r12
cmpq $0x0, 0x8(%r12)
je 0xc8a2
cmpq 0x10(%rsp), %r12
je 0xc5ea
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x7fbe
movl %eax, %ebp
cmpl $0x3, %r14d
jb 0xc5f7
cmpl $-0x1, %ebp
je 0xc5f7
movl %ebp, %edi
movq 0x28(%rsp), %rsi
callq 0x8089
xorl %eax, %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %ebp
setl %al
subl %eax, %ecx
movl %ecx, 0x24(%rsp)
jmp 0xc682
movl $0xc, %eax
movl %r15d, %r13d
jmp 0xc68f
cmpl $-0x1, %ebp
je 0xc676
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xccd1
testl %ebp, %ebp
js 0xc8ff
movq %rax, %r12
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl %ebp, %ecx
movq %r12, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %r12, (%rax,%r13,8)
movq 0x40(%rsp), %rdi
cmpq 0x38(%rsp), %rdi
movl %r15d, %r13d
jne 0xc656
movq 0x8(%rsp), %rax
cmpl 0x20(%rax), %ebp
jae 0xc91e
incl %ebp
movl %ebp, 0x24(%rsp)
movq 0x40(%rsp), %rdi
orb $0x2, 0x15(%rdi)
movq %rdi, %r15
callq 0xcdea
movq %r12, %rdi
movq %r15, %rsi
callq 0x8ba9
xorl %eax, %eax
movq %r12, 0x40(%rsp)
jmp 0xc68a
movl %ebx, %edi
movq 0x18(%rsp), %rsi
callq 0x8089
movl $0xd, %eax
movl %r15d, %r13d
movq 0x8(%rsp), %rbp
cmpl $0xd, %eax
je 0xc698
testl %eax, %eax
jne 0xc6bc
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x7fbe
cmpl $-0x1, %eax
cmovnel %eax, %ebx
incl %r14d
cmpl $0x1, %ebx
jg 0xc57e
jmp 0xc883
movq 0x40(%rsp), %r14
movl 0x28(%r14), %edi
callq 0x7a30
movq %r14, %rdi
callq 0xcdea
orb $0x2, 0x15(%r14)
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x8864
movq %rax, %rbx
movl %edx, %ebp
movl 0x28(%rax), %edi
callq 0x7a30
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x897d
movq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xccd1
orb $0x2, 0x14(%r14)
movq %rax, %rbx
movups 0x18(%rax), %xmm0
movq 0x68(%rsp), %rax
movups (%rax), %xmm1
movups %xmm1, 0x18(%rbx)
movq 0x38(%rsp), %rdi
movups %xmm0, 0x18(%rdi)
movl 0x20(%rbx), %eax
testq %rax, %rax
movq 0x28(%rsp), %r15
je 0xc756
movq 0x18(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rbx, 0x8(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0xc746
movq %rbx, %rsi
callq 0x8ba9
movq %r15, %rdi
movq %r14, %rsi
callq 0x7fbe
cmpl $-0x1, %eax
movl 0x24(%rsp), %r12d
je 0xca35
xorl %ebp, %ebp
cmpl %r12d, %eax
setl %bpl
movl %eax, %edi
movq %r15, %rsi
callq 0x8089
subl %ebp, %r12d
js 0xc9b9
movq 0x8(%rsp), %r14
cmpl 0x20(%r14), %r12d
ja 0xca16
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x7fe1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %r12
movq %r12, %rsi
callq 0x8058
movq %r12, %rdi
movq 0x38(%rsp), %rsi
callq 0x7fbe
cmpl $-0x2, %eax
jle 0xc9d8
incl %eax
cmpl 0x10(%r14), %eax
ja 0xc9f7
movq %rbx, %rdi
movl %eax, %esi
movq 0x18(%rsp), %rdx
callq 0x7fe1
xorl %ebp, %ebp
jmp 0xc82e
movq %rbx, %rdi
callq 0x8107
movq 0x10(%rsp), %r14
cmpq %r14, %rax
je 0xc81b
movq %rbx, %rdi
callq 0xb8b5
movq %rbx, %rdi
callq 0x8107
jmp 0xc804
movq %rbx, %rdi
callq 0xb8b5
movq %r14, %rdi
movq %r15, %rsi
callq 0x8058
testl %ebp, %ebp
movq 0x8(%rsp), %r14
jne 0xc85a
movq 0x60(%rsp), %rax
cmpl $0x7, %eax
leal 0x1(%rax), %eax
setae %cl
movq %rcx, 0x50(%rsp)
movl %eax, %ecx
movq %rcx, 0x60(%rsp)
cmpl $0x8, %eax
jne 0xc334
movq 0x50(%rsp), %rax
andb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0xb8b5
movq $0x0, 0x50(%rsp)
jmp 0xc85a
leaq 0x12725(%rip), %rdi     # 0x1efaf
leaq 0x10f7f(%rip), %rsi     # 0x1d810
leaq 0x1262c(%rip), %rcx     # 0x1eec4
movl $0x862, %edx            # imm = 0x862
callq 0x4100
leaq 0x12750(%rip), %rdi     # 0x1eff9
leaq 0x10f60(%rip), %rsi     # 0x1d810
leaq 0x1260d(%rip), %rcx     # 0x1eec4
movl $0x865, %edx            # imm = 0x865
callq 0x4100
leaq 0x126f6(%rip), %rdi     # 0x1efbe
leaq 0x10f41(%rip), %rsi     # 0x1d810
leaq 0x125ee(%rip), %rcx     # 0x1eec4
movl $0x863, %edx            # imm = 0x863
callq 0x4100
leaq 0x1268a(%rip), %rdi     # 0x1ef71
leaq 0x10f22(%rip), %rsi     # 0x1d810
leaq 0x125cf(%rip), %rcx     # 0x1eec4
movl $0x822, %edx            # imm = 0x822
callq 0x4100
leaq 0x12700(%rip), %rdi     # 0x1f006
leaq 0x10f03(%rip), %rsi     # 0x1d810
leaq 0x125b0(%rip), %rcx     # 0x1eec4
movl $0x886, %edx            # imm = 0x886
callq 0x4100
leaq 0x126f7(%rip), %rdi     # 0x1f01c
leaq 0x10ee4(%rip), %rsi     # 0x1d810
leaq 0x12591(%rip), %rcx     # 0x1eec4
movl $0x88e, %edx            # imm = 0x88E
callq 0x4100
leaq 0x125fa(%rip), %rdi     # 0x1ef3e
leaq 0x10ec5(%rip), %rsi     # 0x1d810
leaq 0x12572(%rip), %rcx     # 0x1eec4
movl $0x819, %edx            # imm = 0x819
callq 0x4100
leaq 0x125a8(%rip), %rdi     # 0x1ef0b
leaq 0x10ea6(%rip), %rsi     # 0x1d810
leaq 0x12553(%rip), %rcx     # 0x1eec4
movl $0x818, %edx            # imm = 0x818
callq 0x4100
leaq 0x125f5(%rip), %rdi     # 0x1ef77
leaq 0x10e87(%rip), %rsi     # 0x1d810
leaq 0x12534(%rip), %rcx     # 0x1eec4
movl $0x837, %edx            # imm = 0x837
callq 0x4100
leaq 0x12608(%rip), %rdi     # 0x1efa9
leaq 0x10e68(%rip), %rsi     # 0x1d810
leaq 0x12515(%rip), %rcx     # 0x1eec4
movl $0x852, %edx            # imm = 0x852
callq 0x4100
leaq 0x126bd(%rip), %rdi     # 0x1f07d
leaq 0x10e49(%rip), %rsi     # 0x1d810
leaq 0x124f6(%rip), %rcx     # 0x1eec4
movl $0x8d5, %edx            # imm = 0x8D5
callq 0x4100
leaq 0x126ac(%rip), %rdi     # 0x1f08b
leaq 0x10e2a(%rip), %rsi     # 0x1d810
leaq 0x124d7(%rip), %rcx     # 0x1eec4
movl $0x8e3, %edx            # imm = 0x8E3
callq 0x4100
leaq 0x1269c(%rip), %rdi     # 0x1f09a
leaq 0x10e0b(%rip), %rsi     # 0x1d810
leaq 0x124b8(%rip), %rcx     # 0x1eec4
movl $0x8e4, %edx            # imm = 0x8E4
callq 0x4100
leaq 0x125ff(%rip), %rdi     # 0x1f01c
leaq 0x10dec(%rip), %rsi     # 0x1d810
leaq 0x12499(%rip), %rcx     # 0x1eec4
movl $0x8d6, %edx            # imm = 0x8D6
callq 0x4100
leaq 0x12625(%rip), %rdi     # 0x1f061
leaq 0x10dcd(%rip), %rsi     # 0x1d810
leaq 0x1247a(%rip), %rcx     # 0x1eec4
movl $0x8c9, %edx            # imm = 0x8C9
callq 0x4100