// File: /workspace/github_cpp_makefile_star2_O3/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 0x35c2
movq %r15, -0xd0(%rbp)
movq %r15, %rdi
callq 0x629c
movq %r12, -0xa0(%rbp)
movq %r12, %rdi
callq 0x61f4
movq %r13, -0xa8(%rbp)
movq %r13, %rdi
callq 0x61f4
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3c20(%rip), %rdx      # 0x8247
leaq -0xf0(%rbp), %rdi
movq %rdx, %rsi
callq 0x29b2
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 0x5561
movq -0x138(%rbp), %rbx
movq %rbx, %rdi
callq 0x20c0
cmpq $0x3e8, %rax            # imm = 0x3E8
jae 0x597a
movq %r13, %rdi
leaq 0x3ac8(%rip), %rsi      # 0x81a3
movq %rbx, %rdx
callq 0x278c
movq %rbx, %rdi
callq 0x20c0
incl %r15d
testq %rax, %rax
je 0x469d
cmpq $0x1, %rax
je 0x5985
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 0x3a78(%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 0x3a4c(%rip), %rdx      # 0x81a5
callq 0x2834
movq %r12, %r13
leaq -0xf0(%rbp), %r12
leal -0x61(%rbx), %eax
cmpl $0x13, %eax
ja 0x4878
leaq 0x39c5(%rip), %rcx      # 0x8140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x4e2b
cmpl $0x1, %eax
jne 0x5aa7
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x448e
movq %rax, %rbx
testq %rax, %rax
je 0x5a03
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc8(%rbp), %rdi
leaq 0x3a79(%rip), %rsi      # 0x8246
leaq 0x3a73(%rip), %rdx      # 0x8247
callq 0x29b2
movq -0x138(%rbp), %r12
leaq -0x100(%rbp), %rax
movq %rax, -0x110(%rbp)
movq %r12, %rdi
callq 0x20c0
leaq (%rax,%r12), %rdx
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
callq 0x29b2
movq -0xc8(%rbp), %rcx
movl $0xf, %edi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rcx
je 0x4828
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %r8
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0x4867
movl $0xf, %edi
leaq -0x100(%rbp), %r9
cmpq %r9, %rsi
je 0x485e
movq -0x100(%rbp), %rdi
cmpq %rdi, %rax
jbe 0x5224
leaq -0xc8(%rbp), %rdi
callq 0x2070
jmp 0x5234
cmpl $0x23, %ebx
je 0x5550
jmp 0x59a5
cmpl $0x3, -0x2c(%rbp)
movl $0x3, -0x2c(%rbp)
je 0x5550
jmp 0x59cc
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x59b4
movq -0x58(%rbp), %rcx
movq 0x88(%rcx), %rax
cmpq 0xc0(%rcx), %rax
jne 0x59bc
movq %r12, %rdi
callq 0x20f0
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x448e
testq %rax, %rax
jne 0x59c4
movq -0x58(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4f92
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rbx, %rbx
je 0x506a
testq %rax, %rax
je 0x59ac
movq 0x30(%rbx), %rcx
subq 0x28(%rbx), %rcx
movq 0x30(%rax), %rdx
subq 0x28(%rax), %rdx
cmpq %rdx, %rcx
jne 0x59ac
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x38ed(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29b2
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2bfa
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x50e3
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x50e9
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x5550
cmpl $0x1, %eax
jne 0x5a17
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
je 0x5a0f
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
je 0x4a4d
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
je 0x4a4d
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
movq %r12, %rsi
movq 0x28(%rax), %r12
movq 0x30(%rax), %rbx
movq -0xa8(%rbp), %rdi
callq 0x631c
subq %r12, %rbx
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
cmpq %rcx, %rbx
leaq -0xf0(%rbp), %r12
je 0x5a0f
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
jne 0x4abf
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 0x5d7e
movq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0x64d6
leaq -0x78(%rbp), %rdi
callq 0x345e
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4ab6
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x345e
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
movq -0x130(%rbp), %rsi
cmpq %rsi, -0x128(%rbp)
je 0x5a1f
addq $0x28, %rax
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x2958
jmp 0x5550
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x59eb
movq %r12, %rdi
callq 0x20f0
movq -0x168(%rbp), %rdi
movq %r12, %rsi
callq 0x448e
testq %rax, %rax
jne 0x59fb
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x36ff(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29b2
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2bfa
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x5002
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x5008
movl -0x2c(%rbp), %eax
cmpl $0x3, %eax
je 0x5550
cmpl $0x1, %eax
jne 0x5a31
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
je 0x4c23
movq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
je 0x4c23
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
movq %r12, %rsi
movq 0x28(%rax), %r12
movq 0x30(%rax), %rbx
movq -0xa8(%rbp), %rdi
callq 0x631c
subq %r12, %rbx
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
cmpq %rcx, %rbx
leaq -0xf0(%rbp), %r12
jne 0x5aaf
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
testq %rax, %rax
jne 0x4c95
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 0x5d7e
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x64d6
leaq -0x78(%rbp), %rdi
callq 0x345e
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4c8c
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x345e
movq -0xa0(%rbp), %rdi
movq %r12, %rsi
callq 0x631c
movq -0x130(%rbp), %rsi
cmpq %rsi, -0x128(%rbp)
je 0x5a39
addq $0x28, %rax
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x2958
jmp 0x5550
cmpl $0x1, -0x2c(%rbp)
jne 0x59d4
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rax
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq $0x3, %rdx
jae 0x59f3
cmpq %rdi, %rax
je 0x5a57
movq %r12, %rsi
callq 0x2030
testl %eax, %eax
je 0x59dc
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6812
testq %rax, %rax
jne 0x4d87
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 0x5e02
movq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6a5c
leaq -0x78(%rbp), %rdi
callq 0x5e86
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4d7e
callq 0x2160
leaq -0x50(%rbp), %rdi
callq 0x5e86
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rdx
subq %rdi, %rdx
cmpq $0x20, %rdx
jne 0x4f0d
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6812
movq -0x130(%rbp), %r12
cmpq %r12, -0x128(%rbp)
je 0x5a95
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 0x6059
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x98(%rbp), %rdx
callq 0x5eba
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
jmp 0x553f
movq -0x168(%rbp), %rdi
movq %r12, %rsi
callq 0x448e
movq %rax, %rbx
testq %rax, %rax
je 0x5a03
leaq -0xb8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc8(%rbp), %rdi
leaq 0x33e4(%rip), %rsi      # 0x8246
leaq 0x33de(%rip), %rdx      # 0x8247
callq 0x29b2
movq -0x138(%rbp), %r12
leaq -0x100(%rbp), %rax
movq %rax, -0x110(%rbp)
movq %r12, %rdi
callq 0x20c0
leaq (%rax,%r12), %rdx
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
callq 0x29b2
movq -0xc8(%rbp), %rcx
movl $0xf, %edi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rcx
je 0x4ebd
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %r8
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0x4efc
movl $0xf, %edi
leaq -0x100(%rbp), %r9
cmpq %r9, %rsi
je 0x4ef3
movq -0x100(%rbp), %rdi
cmpq %rdi, %rax
jbe 0x5149
leaq -0xc8(%rbp), %rdi
callq 0x2070
jmp 0x5159
sarq $0x5, %rdx
cmpq $0x2, %rdx
jb 0x5a4b
addq $0x20, %rdi
movl $0xa, %ecx
leaq 0x343e(%rip), %rsi      # 0x8369
xorl %edx, %edx
callq 0x2280
cmpq $-0x1, %rax
jne 0x5a6c
movq -0xd0(%rbp), %rdi
movq %r12, %rsi
callq 0x6812
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rcx
je 0x5a80
cmpq $0x2, %rdx
jb 0x5a74
addq $0x28, %rax
leaq 0x20(%rsi), %rdx
movl $0x1, -0x2c(%rbp)
movq %rax, %rdi
callq 0x5efc
jmp 0x5550
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x32a2(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29b2
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2bfa
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x5116
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x511c
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 0x433a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x5045
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x505d
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
jmp 0x53e3
testq %rax, %rax
jne 0x59ac
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x31c1(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29b2
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x2bfa
leaq -0x68(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq -0x50(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x54df
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x54e5
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 0x433a
jmp 0x550d
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 0x433a
jmp 0x550d
leaq -0x110(%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 0x517a
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x5180
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 0x30b2(%rip), %rsi      # 0x826a
leaq 0x30ac(%rip), %rdx      # 0x826b
callq 0x29b2
movq -0x50(%rbp), %rcx
movl $0xf, %edi
leaq -0x40(%rbp), %rax
cmpq %rax, %rcx
je 0x51da
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %r8
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0x5216
movl $0xf, %edi
leaq -0x148(%rbp), %r9
cmpq %r9, %rsi
je 0x520d
movq -0x148(%rbp), %rdi
cmpq %rdi, %rax
jbe 0x52ff
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x530f
leaq -0x110(%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 0x5255
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x525b
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 0x2fd7(%rip), %rsi      # 0x826a
leaq 0x2fd1(%rip), %rdx      # 0x826b
callq 0x29b2
movq -0x50(%rbp), %rcx
movl $0xf, %edi
leaq -0x40(%rbp), %rax
cmpq %rax, %rcx
je 0x52b5
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %r8
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0x52f1
movl $0xf, %edi
leaq -0x148(%rbp), %r9
cmpq %r9, %rsi
je 0x52e8
movq -0x148(%rbp), %rdi
cmpq %rdi, %rax
jbe 0x53f9
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x5409
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 0x533c
movq %rdx, -0x98(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x88(%rbp)
jmp 0x5342
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 0x5393
callq 0x2160
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x53ab
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x53bd
callq 0x2160
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x53d5
callq 0x2160
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
cmpq %rax, %rdi
je 0x53ed
callq 0x2160
movl $0x3, -0x2c(%rbp)
jmp 0x5550
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 0x5436
movq %rdx, -0x98(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x88(%rbp)
jmp 0x543c
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 0x548d
callq 0x2160
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x54a5
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x54b7
callq 0x2160
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x54cf
callq 0x2160
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
jmp 0x553f
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 0x433a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x551f
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5537
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5549
callq 0x2160
movl $0x1, -0x2c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x345e
jmp 0x469d
movq %r13, -0x170(%rbp)
movq -0x180(%rbp), %rax
movq (%rax), %r13
movq 0x6a4f(%rip), %r12      # 0xbfc8
movq (%r12), %rcx
leaq 0x2ec6(%rip), %rdi      # 0x844a
movl $0xd, %esi
movl $0x1, %edx
callq 0x22c0
testq %r13, %r13
je 0x583b
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 0x2bfa
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x28(%r13), %rsi
movq 0x30(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x2bfa
movq (%r13), %r13
movq (%r12), %rdi
movq -0x98(%rbp), %rcx
leaq 0x2e55(%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 0x6812
testq %rax, %rax
je 0x56df
movl %r14d, -0x2c(%rbp)
movq (%r12), %rcx
movl $0xe, %esi
movl $0x1, %edx
leaq 0x2e15(%rip), %rdi      # 0x8460
callq 0x22c0
movq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6812
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x5f3e
movq -0xc8(%rbp), %rax
cmpq %rax, -0xc0(%rbp)
leaq 0x2dec(%rip), %r14      # 0x846f
je 0x56c5
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 0x568d
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
callq 0x5e86
leaq -0x98(%rbp), %rbx
movl -0x2c(%rbp), %r14d
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x631c
testq %rax, %rax
je 0x5805
movq (%r12), %rcx
movl $0x17, %esi
movl $0x1, %edx
leaq 0x2d76(%rip), %rdi      # 0x8482
callq 0x22c0
movq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x631c
testq %rax, %rax
je 0x598d
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x5fcc
movq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0x631c
testq %rax, %rax
je 0x5999
addq $0x28, %rax
leaq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x5fcc
movq -0xc8(%rbp), %rax
cmpq %rax, -0xc0(%rbp)
je 0x57e3
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%r12), %rdi
movq (%rax,%rbx), %rdx
leaq 0x2d13(%rip), %rsi      # 0x849a
xorl %eax, %eax
callq 0x2220
movq -0x110(%rbp), %rax
movq -0x108(%rbp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x5969
movq (%r12), %rdi
movq (%rax,%rbx), %rdx
leaq 0x2ced(%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 0x5778
leaq -0x110(%rbp), %rdi
callq 0x345e
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
callq 0x345e
leaq -0x98(%rbp), %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5817
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x582f
callq 0x2160
incl %r14d
testq %r13, %r13
jne 0x55b0
movq (%r12), %rcx
leaq 0x2c6e(%rip), %rdi      # 0x84b4
movl $0x13, %esi
movl $0x1, %edx
callq 0x22c0
movq -0x178(%rbp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x590d
movl $0x1, %ebx
leaq 0x2be4(%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 0x2bfa
leaq -0x40(%rbp), %r15
movq %r15, -0x50(%rbp)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x2bfa
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 0x58ea
callq 0x2160
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5902
callq 0x2160
incl %ebx
testq %r14, %r14
jne 0x5874
movq (%r12), %rcx
leaq 0x2ba9(%rip), %rdi      # 0x84c1
movl $0x6, %esi
movl $0x1, %edx
callq 0x22c0
movq -0x170(%rbp), %rdi
callq 0x21e0
movq -0x138(%rbp), %rdi
callq 0x21e0
movq -0xf0(%rbp), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x5957
callq 0x2160
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b58(%rip), %rdi      # 0x84c8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2250
incl %r15d
movl %r15d, %edi
callq 0x25fe
movl %r15d, %edi
callq 0x2346
leaq 0x277f(%rip), %rdi      # 0x8113
callq 0x2230
leaq 0x2773(%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 0x2709(%rip), %rdi      # 0x8113
callq 0x2230
movl %r15d, %edi
callq 0x2480
movl %r15d, %edi
callq 0x24a6
leaq 0x2aa2(%rip), %rdi      # 0x84c8
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2250
movl %r15d, %edi
callq 0x24f2
leaq 0x2a88(%rip), %rdi      # 0x84c8
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2250
movl $0x1, %eax
movq %rax, -0x160(%rbp)
leaq 0x2a6a(%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 0x2a41(%rip), %rdi      # 0x84c8
movq -0x160(%rbp), %rsi
xorl %eax, %eax
callq 0x2250
leaq 0x2a2c(%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 0x5ac5
jmp 0x5ad6
jmp 0x5c4b
jmp 0x5c4b
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x5dd6
jmp 0x5ad9
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x345e
jmp 0x5c4e
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c07
jmp 0x5c18
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x5e5a
jmp 0x5b1e
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x5e86
jmp 0x5c4e
jmp 0x5c07
jmp 0x5c18
jmp 0x5c4b
jmp 0x5c07
jmp 0x5c18
jmp 0x5c4b
jmp 0x5b59
jmp 0x5b76
jmp 0x5b93
jmp 0x5baa
jmp 0x5bc7
jmp 0x5c4b
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5b79
callq 0x2160
jmp 0x5b79
movq %rax, %r14
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x5b96
callq 0x2160
jmp 0x5b96
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5bad
callq 0x2160
jmp 0x5bad
movq %rax, %r14
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x5bca
callq 0x2160
jmp 0x5bca
movq %rax, %r14
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rax
jmp 0x5c23
jmp 0x5c4b
jmp 0x5c4b
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
jmp 0x5c23
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x351e
jmp 0x5c1b
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5c4e
callq 0x2160
jmp 0x5c4e
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5c4b
jmp 0x5cc1
movq %rax, %r14
jmp 0x5d32
movq %rax, %r14
leaq -0x130(%rbp), %rdi
callq 0x345e
jmp 0x5cc4
jmp 0x5ca1
jmp 0x5ca6
jmp 0x5cc1
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0xe0(%rbp), %r15
leaq -0x88(%rbp), %r13
jmp 0x5d10
jmp 0x5ca6
jmp 0x5ca6
jmp 0x5cc1
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5cc4
callq 0x2160
jmp 0x5cc4
jmp 0x5ca6
movq %rax, %r14
jmp 0x5ce0
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0xe0(%rbp), %r15
leaq -0x40(%rbp), %r12
leaq -0x88(%rbp), %r13
jmp 0x5d02
movq %rax, %r14
movq -0x58(%rbp), %rbx
leaq -0xe0(%rbp), %r15
jmp 0x5d21
movq %rax, %r14
leaq -0x110(%rbp), %rdi
callq 0x345e
movq -0x58(%rbp), %rbx
leaq -0xe0(%rbp), %r15
leaq -0x40(%rbp), %r12
leaq -0x88(%rbp), %r13
leaq -0xc8(%rbp), %rdi
callq 0x345e
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x5d10
callq 0x2160
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0x5d21
callq 0x2160
movq -0xf0(%rbp), %rdi
cmpq %r15, %rdi
je 0x5d32
callq 0x2160
leaq 0x118(%rbx), %rdi
callq 0x60cc
movq -0x168(%rbp), %rdi
callq 0x359a
movq -0xa8(%rbp), %rdi
callq 0x61cc
movq -0xa0(%rbp), %rdi
callq 0x61cc
movq -0xd0(%rbp), %rdi
callq 0x6274
movq %rbx, %rdi
callq 0x359a
movq %r14, %rdi
callq 0x2290