// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/GameEngine.cpp
// Function: GameEngine::GameEngine(_IO_FILE*)
GameEngine::GameEngine (FILE *fp) {
  map_room_descriptions.clear(); // are these done automatically?
  map_room_contents.clear();
  map_room_opts.clear();
  map_room_tags.clear();

  int parseMode = PARSEMODENONE;
  string lastKey = string(""); // the key for the current parseMode
  // (IE: the current room if PARSEMODEROOM)
  char *buf = (char *) calloc(1024, sizeof(char)); // this is simply a
  // temporary string which
  // gets trimmed to modstr
  char *modstr = (char *) calloc(1024, sizeof(char)); // THIS IS THE STRING
  // WE ARE USING!!!
  int linecount = 0; // helps the user debug their text file
  while (fgets(buf, 1023, fp)) {
    linecount++;
    if (strlen(modstr) >= 1000) {
      fprintf(stderr, "line %d: Too long\n", linecount);
      exit(1);
    }
    stringTrim(buf, "\n\r ", modstr); // trim newline, carriage return,
    // and space from front and back
    if (strlen(modstr) == 0) { // skip empty lines
      continue;
    }
    if (strlen(modstr) == 1) {
      fprintf(stderr, "line %d: No parameters specified\n", linecount);
      exit(1);
    }
    char tag = modstr[0]; // in this case, by tag we mean the character of
    // the line (IE: 'r', 'd', 'g', etc.)
    strncpy(buf, modstr, strlen(modstr) + 1); // this line and the
    // following one trim
    // everything from
    stringTrim(buf + 1, "\n\r ", modstr);     // the tag to the beginning
    // of the parameter
    vector<string> params = {};
    stringToParams(modstr, &params, " ");
    // (room for 'r', description for 'd', etc)
    switch (tag) { // REMEMBER: at this point modstr only contains the
      // parameter, tag contains the current tag
      case 'r': // room
        {
          if (params.size() != 1) {
            fprintf(stderr, "line %d: 'r' takes one parameter\n", linecount);
            exit(1);
          }
          // TODO: create a function that checks if it is ok to
          // continue parsing, in other words, checks that the
          // previous thing being modified is ok up to this point
          parseMode = PARSEMODEROOM;

          /* VERY BAD BECAUSE WE DON'T KNOW IF LASTKEY IS A ROOM!,
           * just make a complete checking function already
           if (map_room_descriptions.size() > 0 &&
          // if desc is blank, none specified
          map_room_descriptions.at(lastKey).compare(string("")) == 0) {
          fprintf(stderr, "%s: Room has no description\n",
          list_rooms.back().c_str());
          exit(1);
          }
          */

          if (map_room_opts.size() != map_room_tags.size()) {
            fprintf(stderr, "line %d: There must be one tag for every option\n",
                linecount);
            exit(1);
          }
          lastKey = params.at(0); // key is now the current room
          if (map_room_descriptions.find(lastKey) !=
              map_room_descriptions.end()) {
            fprintf(stderr, "line %d: Can't have duplicate room names\n",
                linecount);
            exit(1);
          }
          if (map_room_descriptions.size() == 0) { // don't check tags if there
            // are no rooms yet
            map_room_descriptions.insert(pair<string, // new entry
                string>(lastKey, string("")));
            break;
          }
          auto opts_iter = map_room_opts.find(lastKey); // the next ~10 lines
          // are for checking
          // opts : tags
          auto tags_iter = map_room_tags.find(lastKey);
          if (opts_iter == map_room_opts.end() &&
              tags_iter == map_room_tags.end()) { // no tags or opts, thus equal
            map_room_descriptions.insert(pair<string,
                string>(lastKey, string(""))); // if unchanged, if
            // statement above is trigerred
            break;
          }
          if (opts_iter == map_room_opts.end() || // only opts has nothing
              tags_iter == map_room_tags.end() || // or only tags has nothing
              opts_iter->second.size() !=
              tags_iter->second.size()) { // or for key: numopts != numtags
            fprintf(stderr, "line %d: There must be one tag for every option\n",
                linecount);
            exit(1);
          }
          map_room_descriptions.insert(pair<string,
              string>(lastKey, string("")));
          break;
        }
      case 'd': // description
        // NOTE: that there is only ever one description per room. The
        // functionality of having multiple descriptions is implemented
        // by appending to the previous description string for a given
        // room if it already exists
        if (parseMode == PARSEMODEROOM) {
          // in all cases, append: we know the entry must exist at
          // this point
          // Note: in this case we take the entire group of parameters excluding
          // the newline and space after the tag as the description
          map_room_descriptions.at(lastKey).append(string("\t")
              + string(modstr) + string("\n"));
        } else if (parseMode == PARSEMODEITEM) {
          // in all cases, append: we know the entry must exist at
          // this point
          // Note: in this case we take the entire group of parameters excluding
          // the newline and space after the tag as the description
          map_item_descriptions.at(lastKey).append(string("\t")
              + string(modstr) + string("\n"));
        } else {
          fprintf(stderr, "line %d: Invalid parsemode for 'd'\n", linecount);
          exit(1);
        }
        break;
      case 'o':
        {
          if (parseMode == PARSEMODEROOM) {
            if (map_room_opts.find(lastKey) != map_room_opts.end() &&
                map_room_tags.find(lastKey) != map_room_tags.end() &&
                map_room_opts.find(lastKey)->second.size() !=
                map_room_tags.find(lastKey)->second.size()) { // numopts should
              // equal numtags
              // at this point
              fprintf(stderr, "line %d: Expected another tag first\n",
                  linecount);
              exit(1);
            }
            // if there are no transitions from the current room, insert
            // a blank one
            if (map_room_opts.find(lastKey) == map_room_opts.end()) {
              map_room_opts.insert(pair<string, vector<string>>(lastKey, {}));
            }
            // finally, append to the appropriate vector
            map_room_opts.find(lastKey)->second.push_back(params.at(0));
          } else if (parseMode == PARSEMODEITEM) {
            // TODO: dat functionality
          } else {
            fprintf(stderr, "line %d: Invalid parsemode for 'o'\n", linecount);
            exit(1);
          }
          break;
        }
      case 't':
        {
          if (parseMode == PARSEMODEROOM) {
            // can't have tags before opts
            if (map_room_opts.find(lastKey) == map_room_opts.end() ||
                (map_room_opts.find(lastKey) != map_room_opts.end() &&
                 map_room_tags.find(lastKey) != map_room_tags.end() &&
                 map_room_opts.find(lastKey)->second.size() ==
                 map_room_tags.find(lastKey)->second.size())) {
              // numopts should equal numtags - 1 at this point
              fprintf(stderr, "line %d: Expected another option first\n",
                  linecount);
              exit(1);
            }
            // if there are no transitions from the current room, insert
            // a blank one
            if (map_room_tags.find(lastKey) == map_room_tags.end())
              map_room_tags.insert(pair<string, vector<string>>(lastKey, {}));
            // finally, append to the appropriate vector
            map_room_tags.find(lastKey)->second.push_back(params.at(0));
          } else if (parseMode == PARSEMODEITEM) {
            // TODO: dat functionality
          } else {
            fprintf(stderr, "line %d: Invalid parsemode for 't'\n", linecount);
            exit(1);
          }
          break;
        }
      case 'm':
        if (parseMode == PARSEMODEROOM) {
          if (params.size() > 2) {
            fprintf(stderr, "line %d: in room parsing, 'm' %s",
                linecount, "takes one or two parameters\n");
            exit(1);
          }
          // Cannot have a room be a member of itself
          if (params.at(0).compare(lastKey) == 0) {
            fprintf(stderr, "line %d: %s cannot be a member of itself\n",
                linecount, modstr);
            exit(1);
          }
          if (map_room_contents.find(lastKey) == map_room_contents.end()) {
            // sometimes life isn't simple but it could be
            map_room_contents.insert(pair<string,
                vector<tuple<string, string>>>(lastKey, {}));
          }
          if (params.size() == 1) {
            map_room_contents.find(lastKey)->second.emplace_back(
                params.at(0), to_string(PRIORITYDEFAULT));
          } else {
            if (params.at(1).find_first_not_of("1234567890") != string::npos) {
              fprintf(stderr, "line %d: Priority must be an integer\n",
                  linecount);
              exit(1);
            }
            map_room_contents.find(lastKey)->second.emplace_back(
                params.at(0), params.at(1));
          }
        } else {
          fprintf(stderr, "line %d: Invalid parsemode for 'm'\n", linecount);
          exit(1);
        }
        break;
      case 'e':
        // TODO
        break;
      case 'a':
        // TODO
        break;
      case 'i':
        {
          // TODO: create a function that checks if it is ok to
          // continue parsing, in other words, checks that the
          // previous thing being modified is ok up to this point
          parseMode = PARSEMODEITEM;
          if (params.size() != 1) {
            fprintf(stderr, "line %d: 'i' takes one parameter\n", linecount);
            exit(1);
          }
          lastKey = params.at(0); // key is now the current item
          if (map_item_descriptions.find(lastKey) !=
              map_item_descriptions.end()) {
            fprintf(stderr, "line %d: Can't have duplicate item names\n",
                linecount);
            exit(1);
          }
          map_item_descriptions.insert(pair<string, // new entry
              string>(lastKey, string("")));
          break;
        }
      case 'q':
        {
          if (parseMode == PARSEMODEITEM) {
            // TODO
          } else {
            fprintf(stderr, "line %d: Invalid parsemode for 'q'\n", linecount);
            exit(1);
          }
          break;
        }
      case '#': // support those comments
        // Yes, this works.
        break;
      default:
        fprintf(stderr, "%c: No Corresponding field\n", tag);
        exit(1);
        break;
    }
  }
  /* General checking function needed
     if (list_rooms.size() != list_room_descriptions.size()) {
// one description per room required
fprintf(stderr, "%s: Room has no description\n",
list_rooms.back().c_str());
exit(1); }
*/
  // TODO resolve regex
  // TODO:
  // check that for all keys num opts = num tags and all opts are valid rooms
  // (will have to add checking for non-visitable rooms later)

  // print all info
  auto iter_room = map_room_descriptions.begin();
  int count_rooms = 1;
  fprintf(stdout, "ROOMS:\n=====\n");
  while (iter_room != map_room_descriptions.end()) {
    string room = iter_room->first;
    string description = iter_room->second;
    iter_room++;
    fprintf(stdout, "%d: %s\n", count_rooms++, room.c_str());
    // assumes description was modified in a certain way first
    fprintf(stdout, "%s", description.c_str());
    if (map_room_contents.find(room) != map_room_contents.end()) {
      fprintf(stdout, "\tHas Members:\n");
      auto list_contents = map_room_contents.find(room)->second;
      for (size_t k = 0; k < list_contents.size(); k++) {
        fprintf(stdout, "\t\t%s: Priority=%s\n",
            get<0>(list_contents.at(k)).c_str(),
            get<1>(list_contents.at(k)).c_str());
      }
    }
    // if no opts/tags
    if (map_room_opts.find(room) == map_room_opts.end()) continue;
    fprintf(stdout, "\tHas Options and Tags:\n");
    auto list_opts = map_room_opts.at(room);
    auto list_tags = map_room_tags.at(room);
    for (size_t k = 0; k < list_opts.size(); k++) { // since numopts = numtags
      fprintf(stdout, "\t\tOption: %s\n", list_opts.at(k).c_str());
      fprintf(stdout, "\t\t\tTag: %s\n", list_tags.at(k).c_str());
    }
  }
  fprintf(stdout, "=====\nITEMS:\n=====\n");
  auto iter_items = map_item_descriptions.begin();
  int count_items = 1;
  // print item info
  while(iter_items != map_item_descriptions.end()) {
    string item = iter_items->first;
    string description = iter_items->second;
    iter_items++;
    fprintf(stdout, "%d: %s\n", count_items++, item.c_str());
    // assumes description was modified in a certain way first
    fprintf(stdout, "%s", description.c_str());
  }
  fprintf(stdout, "=====\n");
  free(buf);
  free(modstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movl $0x1, %eax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
leaq 0x38(%rdi), %r15
leaq 0x68(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movl %ecx, 0x58(%rdi)
movups %xmm0, 0x60(%rdi)
leaq 0x70(%rdi), %r12
leaq 0xa0(%rdi), %rdx
movq %rdx, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movups %xmm0, 0x80(%rdi)
movl %ecx, 0x90(%rdi)
movups %xmm0, 0x98(%rdi)
leaq 0xa8(%rdi), %r13
leaq 0xd8(%rdi), %rdx
movq %rdx, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
movups %xmm0, 0xb8(%rdi)
movl %ecx, 0xc8(%rdi)
movups %xmm0, 0xd0(%rdi)
leaq 0xe0(%rdi), %rdx
movq %rdx, -0x168(%rbp)
leaq 0x110(%rdi), %rdx
movq %rdx, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movups %xmm0, 0xf0(%rdi)
movl %ecx, 0x100(%rdi)
movups %xmm0, 0x108(%rdi)
leaq 0x148(%rdi), %rdx
movq %rdx, 0x118(%rdi)
movq %rax, 0x120(%rdi)
movups %xmm0, 0x128(%rdi)
movl %ecx, 0x138(%rdi)
movups %xmm0, 0x140(%rdi)
callq 0x35ee
movq %r15, -0xd0(%rbp)
movq %r15, %rdi
callq 0x62a8
movq %r12, -0xa0(%rbp)
movq %r12, %rdi
callq 0x6200
movq %r13, -0xa8(%rbp)
movq %r13, %rdi
callq 0x6200
leaq -0x100(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3c1c(%rip), %rdx      # 0x8247
leaq -0x110(%rbp), %rdi
movq %rdx, %rsi
callq 0x29ba
leaq 0x10(%rbx), %rax
movq %rax, -0x180(%rbp)
movq %rbx, -0x58(%rbp)
leaq 0xf0(%rbx), %rax
movq %rax, -0x178(%rbp)
movl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
callq 0x2110
movq %rax, %r13
movl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
callq 0x2110
movq %rax, -0x138(%rbp)
movq %r13, %rax
incq %rax
movq %rax, -0x170(%rbp)
movq $0x0, -0x160(%rbp)
xorl %r15d, %r15d
movl $0x0, -0x2c(%rbp)
movq %r13, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
movq %r14, %rdx
callq 0x2260
testq %rax, %rax
je 0x5575
movq -0x138(%rbp), %rbx
movq %rbx, %rdi
callq 0x20c0
cmpq $0x3e8, %rax            # imm = 0x3E8
jae 0x598e
movq %r13, %rdi
leaq 0x3ac4(%rip), %rsi      # 0x81a3
movq %rbx, %rdx
callq 0x278c
movq %rbx, %rdi
callq 0x20c0
incl %r15d
testq %rax, %rax
je 0x46a1
cmpq $0x1, %rax
je 0x5999
movq %r13, %r12
movq -0x138(%rbp), %r13
movzbl (%r13), %ebx
incq %rax
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20d0
movq -0x170(%rbp), %rdi
leaq 0x3a74(%rip), %rsi      # 0x81a3
movq %r13, %rdx
callq 0x278c
xorps %xmm0, %xmm0
movaps %xmm0, -0x130(%rbp)
movq $0x0, -0x120(%rbp)
movq %r13, %rdi
leaq -0x130(%rbp), %rsi
leaq 0x3a48(%rip), %rdx      # 0x81a5
callq 0x2834
movq %r12, %r13
leaq -0x110(%rbp), %r12
leal -0x61(%rbx), %eax
cmpl $0x13, %eax
ja 0x4880
leaq 0x39c1(%rip), %rcx      # 0x8140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x4daf
cmpl $0x1, %eax
jne 0x5abb
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x4492
movq %rax, %rbx
testq %rax, %rax
je 0x5a17
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc8(%rbp), %rdi
leaq 0x3a75(%rip), %rsi      # 0x8246
leaq 0x3a6f(%rip), %rdx      # 0x8247
callq 0x29ba
movq -0x138(%rbp), %r12
leaq -0xe0(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq %r12, %rdi
callq 0x20c0
leaq (%rax,%r12), %rdx
leaq -0xf0(%rbp), %rdi
movq %r12, %rsi
callq 0x29ba
movq -0xc8(%rbp), %rcx
movl $0xf, %esi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rcx
je 0x482c
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %r8
movq -0xe8(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x4868
movl $0xf, %esi
leaq -0xe0(%rbp), %rdi
cmpq %rdi, -0xf0(%rbp)
je 0x485f
movq -0xe0(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x51fa
movq -0xf0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x2070
jmp 0x520a
cmpl $0x23, %ebx
je 0x54c8
jmp 0x59b9
cmpl $0x3, -0x2c(%rbp)
movl $0x3, -0x2c(%rbp)
je 0x54c8
jmp 0x59e0
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x59c8
movq -0x58(%rbp), %rcx
movq 0x88(%rcx), %rax
cmpq 0xc0(%rcx), %rax
jne 0x59d0
movq %r12, %rdi
callq 0x20f0
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x4492
testq %rax, %rax
jne 0x59d8
movq -0x58(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4f1a
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rbx, %rbx
je 0x4ff2
testq %rax, %rax
jne 0x5004
jmp 0x59c0
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x54c8
cmpl $0x1, %eax
jne 0x5a2b
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
je 0x5a23
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
je 0x49d1
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
je 0x49d1
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
movq %r12, %rsi
movq 0x28(%rax), %r12
movq 0x30(%rax), %rbx
movq -0xa8(%rbp), %rdi
callq 0x6328
subq %r12, %rbx
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
cmpq %rcx, %rbx
leaq -0x110(%rbp), %r12
je 0x5a23
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
jne 0x4a43
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x50(%rbp), %rdx
callq 0x5d8a
movq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0x64e2
leaq -0x78(%rbp), %rdi
callq 0x3494
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4a3a
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x3494
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
movq -0x130(%rbp), %rsi
cmpq %rsi, -0x128(%rbp)
je 0x5a33
addq $0x28, %rax
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x2960
jmp 0x54c8
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x59ff
movq %r12, %rdi
callq 0x20f0
movq -0x168(%rbp), %rdi
movq %r12, %rsi
callq 0x4492
testq %rax, %rax
jne 0x5a0f
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x377b(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29ba
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2c30
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x4f8a
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x4f90
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x54c8
cmpl $0x1, %eax
jne 0x5a45
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
je 0x4ba7
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
je 0x4ba7
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
movq %r12, %rsi
movq 0x28(%rax), %r12
movq 0x30(%rax), %rbx
movq -0xa8(%rbp), %rdi
callq 0x6328
subq %r12, %rbx
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
cmpq %rcx, %rbx
leaq -0x110(%rbp), %r12
jne 0x5ac3
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
testq %rax, %rax
jne 0x4c19
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x50(%rbp), %rdx
callq 0x5d8a
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x64e2
leaq -0x78(%rbp), %rdi
callq 0x3494
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4c10
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x3494
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x6328
movq -0x130(%rbp), %rsi
cmpq %rsi, -0x128(%rbp)
je 0x5a4d
addq $0x28, %rax
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x2960
jmp 0x54c8
cmpl $0x1, -0x2c(%rbp)
jne 0x59e8
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rax
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq $0x3, %rdx
jae 0x5a07
cmpq %rdi, %rax
je 0x5a6b
movq %r12, %rsi
callq 0x2030
testl %eax, %eax
je 0x59f0
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6820
testq %rax, %rax
jne 0x4d0b
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x50(%rbp), %rdx
callq 0x5e0e
movq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6a6a
leaq -0x78(%rbp), %rdi
callq 0x5e92
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4d02
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x5e92
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rdx
subq %rdi, %rdx
cmpq $0x20, %rdx
jne 0x4e95
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6820
movq -0x130(%rbp), %r12
cmpq %r12, -0x128(%rbp)
je 0x5aa9
movq %rax, %rbx
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x3, %esi
leaq -0x98(%rbp), %rdi
movl $0x2d, %edx
callq 0x21c0
addq $0x28, %rbx
movq -0x98(%rbp), %rdi
movl $0x3, %esi
movl $0x64, %edx
callq 0x6065
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x98(%rbp), %rdx
callq 0x5ec6
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
jmp 0x54b7
movq -0x168(%rbp), %rdi
movq %r12, %rsi
callq 0x4492
movq %rax, %rbx
testq %rax, %rax
je 0x5a17
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc8(%rbp), %rdi
leaq 0x3460(%rip), %rsi      # 0x8246
leaq 0x345a(%rip), %rdx      # 0x8247
callq 0x29ba
movq -0x138(%rbp), %r12
leaq -0xe0(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq %r12, %rdi
callq 0x20c0
leaq (%rax,%r12), %rdx
leaq -0xf0(%rbp), %rdi
movq %r12, %rsi
callq 0x29ba
movq -0xc8(%rbp), %rcx
movl $0xf, %esi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rcx
je 0x4e41
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %r8
movq -0xe8(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x4e7d
movl $0xf, %esi
leaq -0xe0(%rbp), %rdi
cmpq %rdi, -0xf0(%rbp)
je 0x4e74
movq -0xe0(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x511b
movq -0xf0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x2070
jmp 0x512b
sarq $0x5, %rdx
cmpq $0x2, %rdx
jb 0x5a5f
addq $0x20, %rdi
movl $0xa, %ecx
leaq 0x34b6(%rip), %rsi      # 0x8369
xorl %edx, %edx
callq 0x2280
cmpq $-0x1, %rax
jne 0x5a80
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6820
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rcx
je 0x5a94
cmpq $0x2, %rdx
jb 0x5a88
addq $0x28, %rax
leaq 0x20(%rsi), %rdx
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x5f08
jmp 0x54c8
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x331a(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29ba
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2c30
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x50b6
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x50bc
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rcx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x168(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x433c
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x4fcd
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4fe5
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
jmp 0x53bd
testq %rax, %rax
je 0x54d9
testq %rbx, %rbx
je 0x59c0
movq 0x30(%rbx), %rcx
subq 0x28(%rbx), %rcx
movq 0x30(%rax), %rdx
subq 0x28(%rax), %rdx
cmpq %rdx, %rcx
jne 0x59c0
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3217(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29ba
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2c30
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x5086
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x508c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rcx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x433c
jmp 0x50e4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rcx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x433c
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x50f6
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x510e
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
jmp 0x54b7
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq -0x40(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x514c
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x5152
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x48(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x158(%rbp), %rdi
leaq 0x30e0(%rip), %rsi      # 0x826a
leaq 0x30da(%rip), %rdx      # 0x826b
callq 0x29ba
movq -0x50(%rbp), %rcx
movl $0xf, %esi
leaq -0x40(%rbp), %rax
cmpq %rax, %rcx
je 0x51ac
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %r8
movq -0x150(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x51e5
movl $0xf, %esi
leaq -0x148(%rbp), %rdi
cmpq %rdi, -0x158(%rbp)
je 0x51dc
movq -0x148(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x52d9
movq -0x158(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x52e9
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq -0x40(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x522b
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x5231
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x48(%rbp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x158(%rbp), %rdi
leaq 0x3001(%rip), %rsi      # 0x826a
leaq 0x2ffb(%rip), %rdx      # 0x826b
callq 0x29ba
movq -0x50(%rbp), %rcx
movl $0xf, %esi
leaq -0x40(%rbp), %rax
cmpq %rax, %rcx
je 0x528b
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %r8
movq -0x150(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x52c4
movl $0xf, %esi
leaq -0x148(%rbp), %rdi
cmpq %rdi, -0x158(%rbp)
je 0x52bb
movq -0x148(%rbp), %rsi
cmpq %rsi, %rax
jbe 0x53d3
movq -0x158(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x53e3
leaq -0x158(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq -0x88(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x5316
movq %rdx, -0x98(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x88(%rbp)
jmp 0x531c
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x90(%rbp)
movq %rcx, (%rax)
addq $0x28, %rbx
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0x2070
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x536d
callq 0x2160
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x5385
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5397
callq 0x2160
movq -0xf0(%rbp), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x53af
callq 0x2160
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rdi
je 0x53c7
callq 0x2160
movl $0x3, -0x2c(%rbp)
jmp 0x54c8
leaq -0x158(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq -0x88(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x5410
movq %rdx, -0x98(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x88(%rbp)
jmp 0x5416
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x90(%rbp)
movq %rcx, (%rax)
addq $0x28, %rbx
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0x2070
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5467
callq 0x2160
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x547f
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5491
callq 0x2160
movq -0xf0(%rbp), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x54a9
callq 0x2160
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rdi
je 0x54c1
callq 0x2160
movl $0x1, -0x2c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3494
jmp 0x46a1
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x2d5b(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29ba
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2c30
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x5542
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x5548
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rcx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x433c
jmp 0x50e4
movq %r13, -0x170(%rbp)
movq -0x180(%rbp), %rax
movq (%rax), %r13
movq 0x6a3b(%rip), %r12      # 0xbfc8
movq (%r12), %rcx
leaq 0x2eb2(%rip), %rdi      # 0x844a
movl $0xd, %esi
movl $0x1, %edx
callq 0x22c0
testq %r13, %r13
je 0x584f
movl $0x1, %r14d
leaq -0x98(%rbp), %rbx
leaq -0xc8(%rbp), %r15
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c30
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x28(%r13), %rsi
movq 0x30(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x2c30
movq (%r13), %r13
movq (%r12), %rdi
movq -0x98(%rbp), %rcx
leaq 0x2e41(%rip), %rsi      # 0x8458
movl %r14d, %edx
xorl %eax, %eax
callq 0x2220
movq (%r12), %rsi
movq -0x50(%rbp), %rdi
callq 0x21a0
movq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6820
testq %rax, %rax
je 0x56f3
movl %r14d, -0x2c(%rbp)
movq (%r12), %rcx
movl $0xe, %esi
movl $0x1, %edx
leaq 0x2e01(%rip), %rdi      # 0x8460
callq 0x22c0
movq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6820
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x5f4a
movq -0xc8(%rbp), %rax
cmpq %rax, -0xc0(%rbp)
leaq 0x2dd8(%rip), %r14      # 0x846f
je 0x56d9
movl $0x20, %ebx
xorl %r15d, %r15d
movq (%r12), %rdi
movq -0x20(%rax,%rbx), %rcx
movq (%rax,%rbx), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
incq %r15
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
addq $0x40, %rbx
cmpq %rcx, %r15
jb 0x56a1
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
callq 0x5e92
leaq -0x98(%rbp), %rbx
movl -0x2c(%rbp), %r14d
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6328
testq %rax, %rax
je 0x5819
movq (%r12), %rcx
movl $0x17, %esi
movl $0x1, %edx
leaq 0x2d62(%rip), %rdi      # 0x8482
callq 0x22c0
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6328
testq %rax, %rax
je 0x59a1
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x5fd8
movq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0x6328
testq %rax, %rax
je 0x59ad
addq $0x28, %rax
leaq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x5fd8
movq -0xc8(%rbp), %rax
cmpq %rax, -0xc0(%rbp)
je 0x57f7
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%r12), %rdi
movq (%rax,%rbx), %rdx
leaq 0x2cff(%rip), %rsi      # 0x849a
xorl %eax, %eax
callq 0x2220
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x597d
movq (%r12), %rdi
movq (%rax,%rbx), %rdx
leaq 0x2cd9(%rip), %rsi      # 0x84a8
xorl %eax, %eax
callq 0x2220
incq %r15
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbx
cmpq %rcx, %r15
jb 0x578c
leaq -0xf0(%rbp), %rdi
callq 0x3494
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
callq 0x3494
leaq -0x98(%rbp), %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x582b
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5843
callq 0x2160
incl %r14d
testq %r13, %r13
jne 0x55c4
movq (%r12), %rcx
leaq 0x2c5a(%rip), %rdi      # 0x84b4
movl $0x13, %esi
movl $0x1, %edx
callq 0x22c0
movq -0x178(%rbp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x5921
movl $0x1, %ebx
leaq 0x2bd0(%rip), %r13      # 0x8458
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2c30
leaq -0x40(%rbp), %r15
movq %r15, -0x50(%rbp)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x2c30
movq (%r14), %r14
movq (%r12), %rdi
movq -0x98(%rbp), %rcx
movq %r13, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2220
movq (%r12), %rsi
movq -0x50(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x58fe
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5916
callq 0x2160
incl %ebx
testq %r14, %r14
jne 0x5888
movq (%r12), %rcx
leaq 0x2b95(%rip), %rdi      # 0x84c1
movl $0x6, %esi
movl $0x1, %edx
callq 0x22c0
movq -0x170(%rbp), %rdi
callq 0x21e0
movq -0x138(%rbp), %rdi
callq 0x21e0
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x596b
callq 0x2160
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b44(%rip), %rdi      # 0x84c8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2250
incl %r15d
movl %r15d, %edi
callq 0x25fe
movl %r15d, %edi
callq 0x2346
leaq 0x276b(%rip), %rdi      # 0x8113
callq 0x2230
leaq 0x275f(%rip), %rdi      # 0x8113
callq 0x2230
movl %ebx, %edi
callq 0x25d6
movl %r15d, %edi
callq 0x25b0
movl %r15d, %edi
callq 0x253e
movl %r15d, %edi
callq 0x2564
movl %r15d, %edi
callq 0x258a
movl %r15d, %edi
callq 0x236c
movl %r15d, %edi
callq 0x23de
movl %r15d, %edi
movq -0x138(%rbp), %rsi
callq 0x242a
movl %r15d, %edi
callq 0x2392
movl %r15d, %edi
callq 0x2453
movl %r15d, %edi
callq 0x23b8
leaq 0x26f5(%rip), %rdi      # 0x8113
callq 0x2230
movl %r15d, %edi
callq 0x2480
movl %r15d, %edi
callq 0x24a6
leaq 0x2a8e(%rip), %rdi      # 0x84c8
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2250
movl %r15d, %edi
callq 0x24f2
leaq 0x2a74(%rip), %rdi      # 0x84c8
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2250
movl $0x1, %eax
movq %rax, -0x160(%rbp)
leaq 0x2a56(%rip), %rdi      # 0x84c8
movq -0x160(%rbp), %rsi
xorl %eax, %eax
callq 0x2250
movl %r15d, %edi
callq 0x2404
movl $0x1, %eax
movq %rax, -0x160(%rbp)
leaq 0x2a2d(%rip), %rdi      # 0x84c8
movq -0x160(%rbp), %rsi
xorl %eax, %eax
callq 0x2250
leaq 0x2a18(%rip), %rdi      # 0x84c8
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2250
movl %r15d, %edi
callq 0x2518
movl %r15d, %edi
callq 0x24cc
jmp 0x5c12
jmp 0x5c23
jmp 0x5c56
jmp 0x5ae8
jmp 0x5af9
jmp 0x5c56
jmp 0x5c56
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x5de2
jmp 0x5afc
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3494
jmp 0x5c59
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x5e66
jmp 0x5b32
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x5e92
jmp 0x5c59
jmp 0x5c12
jmp 0x5c23
jmp 0x5c56
jmp 0x5b5e
jmp 0x5b7b
jmp 0x5b98
jmp 0x5baf
jmp 0x5bcc
jmp 0x5c56
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5b7e
callq 0x2160
jmp 0x5b7e
movq %rax, %r14
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x5b9b
callq 0x2160
jmp 0x5b9b
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5bb2
callq 0x2160
jmp 0x5bb2
movq %rax, %r14
movq -0xf0(%rbp), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x5bcf
callq 0x2160
jmp 0x5bcf
movq %rax, %r14
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
jmp 0x5c2e
jmp 0x5c56
jmp 0x5c56
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
jmp 0x5c2e
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c12
jmp 0x5c23
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x354a
jmp 0x5c26
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5c59
callq 0x2160
jmp 0x5c59
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5c56
jmp 0x5ccc
movq %rax, %r14
jmp 0x5d3d
movq %rax, %r14
leaq -0x130(%rbp), %rdi
callq 0x3494
jmp 0x5ccf
jmp 0x5cac
jmp 0x5cb1
jmp 0x5ccc
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0x100(%rbp), %r15
leaq -0x88(%rbp), %r13
jmp 0x5d1b
jmp 0x5cb1
jmp 0x5cb1
jmp 0x5ccc
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5ccf
callq 0x2160
jmp 0x5ccf
jmp 0x5cb1
movq %rax, %r14
jmp 0x5ceb
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0x100(%rbp), %r15
leaq -0x40(%rbp), %r12
leaq -0x88(%rbp), %r13
jmp 0x5d0d
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0x100(%rbp), %r15
jmp 0x5d2c
movq %rax, %r14
leaq -0xf0(%rbp), %rdi
callq 0x3494
movq -0x58(%rbp), %rbx
leaq -0x100(%rbp), %r15
leaq -0x40(%rbp), %r12
leaq -0x88(%rbp), %r13
leaq -0xc8(%rbp), %rdi
callq 0x3494
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x5d1b
callq 0x2160
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0x5d2c
callq 0x2160
movq -0x110(%rbp), %rdi
cmpq %r15, %rdi
je 0x5d3d
callq 0x2160
leaq 0x118(%rbx), %rdi
callq 0x60d8
movq -0x168(%rbp), %rdi
callq 0x35c6
movq -0xa8(%rbp), %rdi
callq 0x61d8
movq -0xa0(%rbp), %rdi
callq 0x61d8
movq -0xd0(%rbp), %rdi
callq 0x6280
movq %rbx, %rdi
callq 0x35c6
movq %r14, %rdi
callq 0x2290
nop