// File: razimantv[P]DancingLinks/dominosa/dominosa.cpp
// Function: main
int main() {
  // Read the height of the board
  // In classic dominosa, the width and domino limit depend on H alone
  //  and need not be input separately
  int H, W, L;
  scanf("%d", &H);
  if (H < 1) {
    printf("Invalid board size\n");
    return 0;
  }
  W = H + 1;
  L = H;

  // Allocate memory for the board
  int **board;
  board = new (nothrow) int *[H];
  if (board == NULL) {
    printf("Memory allocation error\n");
    return 1;
  }
  for (int i = 0; i < H; i++) {
    board[i] = new (nothrow) int[W];
    if (board[i] == NULL) {
      printf("Memory allocation error\n");
      return 1;
    }
  }

  // Read the board
  for (int i = 0; i < H; i++)
    for (int j = 0; j < W; j++) {
      scanf("%d", &board[i][j]);
      if ((board[i][j] < 0) || (board[i][j] >= L)) {
        printf("Invalid entry found in the board\n");
        return 1;
      }
    }

  // Every domino is a subset. Hence R=H*(W-1)+W*(H-1)
  // Every position being filled and every pair of numbers appearing in a domino
  //  are essential constraints. Hence C1=H*W+L*L
  // There are no non-essential constraints. Hence C2=0
  int horiz_dom_count = H * (W - 1), vert_dom_count = W * (H - 1);
  int pos_count = H * W, dom_type_count = L * L;
  int R = horiz_dom_count + vert_dom_count, C1 = pos_count + dom_type_count,
      C2 = 0, C = C1 + C2;

  // Matrix to store the constraint adjacency matrix
  char *mat;
  mat = new (nothrow) char[R * C];
  if (mat == NULL) {
    printf("Memory allocation error\n");
    return 1;
  }
  memset(mat, 0, R * C);

  // Deal with horizontal dominoes from (i,j) to (i,j+1)
  for (int i = 0; i < H; i++) {
    for (int j = 0; j < W - 1; j++) {
      // The domino corresponds to row# i*(W-1)+j of adjacency matrix
      int r = i * (W - 1) + j;

      // Position constraint for (i,j) is column# i*W+j of adjacency matrix
      int c1 = i * W + j, c2 = i * W + j + 1;

      // Domino constraint for (d,e) is column# H*W+d*L+e of adjacency matrix
      int c3 = pos_count + board[i][j] * L + board[i][j + 1];
      int c4 = pos_count + board[i][j + 1] * L + board[i][j];

      mat[r * (H * W + L * L) + c1] = 1;
      mat[r * (H * W + L * L) + c2] = 1;
      mat[r * (H * W + L * L) + c3] = 1;
      mat[r * (H * W + L * L) + c4] = 1;
    }
  }

  // Deal with vertical dominoes from (i,j) to (i+1,j)
  for (int i = 0; i < H - 1; i++) {
    for (int j = 0; j < W; j++) {
      // The domino corresponds to row# horiz_dom_count+i*(W-1)+j
      int r = horiz_dom_count + i * W + j;

      // Columns of constraint are same as earlier
      int c1 = i * W + j, c2 = (i + 1) * W + j;
      int c3 = H * W + board[i][j] * L + board[i + 1][j],
          c4 = H * W + board[i + 1][j] * L + board[i][j];

      mat[r * (H * W + L * L) + c1] = 1;
      mat[r * (H * W + L * L) + c2] = 1;
      mat[r * (H * W + L * L) + c3] = 1;
      mat[r * (H * W + L * L) + c4] = 1;
    }
  }

  // Now just solve it with dancing links
  // Note that we are asking it to find only one solution
  DancingLinks N;
  N.Create(R, C1, C2, mat);
  std::vector<std::vector<int> > all;
  std::vector<int> cur;
  N.solve(all, cur, false);

  // If a solution exists, print it
  if (all.size() == 1) {
    char *outputboard;
    outputboard = new char[H * W];
    if (outputboard == NULL) {
      printf("Memory allocation error\n");
      return 1;
    }
    for (int i = 0; i < all.size(); i++) {
      for (int j = 0; j < all[i].size(); j++) {
        int id = all[i][j];
        if (id < H * (W - 1)) {
          int r = id / (W - 1), c = id % (W - 1);
          outputboard[r * W + c] = outputboard[r * W + c + 1] = '-';
        } else {
          id -= H * (W - 1);
          int r = id / W, c = id % W;
          outputboard[r * W + c] = outputboard[(r + 1) * W + c] = '|';
        }
      }

      for (int i = 0, k = 0; i < H; i++) {
        for (int j = 0; j < W; j++, k++) printf("%c", outputboard[k]);
        printf("\n");
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movl $0x0, 0x144(%rsp)
leaq 0x4d8b(%rip), %rdi      # 0x6004
leaq 0x140(%rsp), %rsi
movb $0x0, %al
callq 0x10e0
cmpl $0x1, 0x140(%rsp)
jge 0x12b0
leaq 0x4d6e(%rip), %rdi      # 0x6007
movb $0x0, %al
callq 0x1040
movl $0x0, 0x144(%rsp)
jmp 0x1ee0
movl 0x140(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x13c(%rsp)
movl 0x140(%rsp), %eax
movl %eax, 0x138(%rsp)
movslq 0x140(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq 0x7cd6(%rip), %rsi      # 0x8fd0
callq 0x1130
movq %rax, 0x130(%rsp)
cmpq $0x0, 0x130(%rsp)
jne 0x1330
leaq 0x4d02(%rip), %rdi      # 0x601b
movb $0x0, %al
callq 0x1040
movl $0x1, 0x144(%rsp)
jmp 0x1ee0
movl $0x0, 0x12c(%rsp)
movl 0x12c(%rsp), %eax
cmpl 0x140(%rsp), %eax
jge 0x13e3
movslq 0x13c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq 0x7c56(%rip), %rsi      # 0x8fd0
callq 0x1130
movq %rax, %rdx
movq 0x130(%rsp), %rax
movslq 0x12c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x130(%rsp), %rax
movslq 0x12c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x13cb
leaq 0x4c67(%rip), %rdi      # 0x601b
movb $0x0, %al
callq 0x1040
movl $0x1, 0x144(%rsp)
jmp 0x1ee0
jmp 0x13cd
movl 0x12c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x12c(%rsp)
jmp 0x133b
movl $0x0, 0x128(%rsp)
movl 0x128(%rsp), %eax
cmpl 0x140(%rsp), %eax
jge 0x14ea
movl $0x0, 0x124(%rsp)
movl 0x124(%rsp), %eax
cmpl 0x13c(%rsp), %eax
jge 0x14d2
movq 0x130(%rsp), %rax
movslq 0x128(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movslq 0x124(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x4bb9(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x10e0
movq 0x130(%rsp), %rax
movslq 0x128(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x124(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x149c
movq 0x130(%rsp), %rax
movslq 0x128(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x124(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x138(%rsp), %eax
jl 0x14ba
leaq 0x4b91(%rip), %rdi      # 0x6034
movb $0x0, %al
callq 0x1040
movl $0x1, 0x144(%rsp)
jmp 0x1ee0
jmp 0x14bc
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
jmp 0x140d
jmp 0x14d4
movl 0x128(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x128(%rsp)
jmp 0x13ee
movl 0x140(%rsp), %eax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, 0x120(%rsp)
movl 0x13c(%rsp), %eax
movl 0x140(%rsp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, 0x11c(%rsp)
movl 0x140(%rsp), %eax
imull 0x13c(%rsp), %eax
movl %eax, 0x118(%rsp)
movl 0x138(%rsp), %eax
imull 0x138(%rsp), %eax
movl %eax, 0x114(%rsp)
movl 0x120(%rsp), %eax
addl 0x11c(%rsp), %eax
movl %eax, 0x110(%rsp)
movl 0x118(%rsp), %eax
addl 0x114(%rsp), %eax
movl %eax, 0x10c(%rsp)
movl $0x0, 0x108(%rsp)
movl 0x10c(%rsp), %eax
addl 0x108(%rsp), %eax
movl %eax, 0x104(%rsp)
movl 0x110(%rsp), %eax
imull 0x104(%rsp), %eax
movslq %eax, %rdi
movq 0x7a21(%rip), %rsi      # 0x8fd0
callq 0x1130
movq %rax, 0xf8(%rsp)
cmpq $0x0, 0xf8(%rsp)
jne 0x15e5
leaq 0x4a4d(%rip), %rdi      # 0x601b
movb $0x0, %al
callq 0x1040
movl $0x1, 0x144(%rsp)
jmp 0x1ee0
movq 0xf8(%rsp), %rdi
movl 0x110(%rsp), %eax
imull 0x104(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1090
movl $0x0, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
cmpl 0x140(%rsp), %eax
jge 0x188c
movl $0x0, 0xf0(%rsp)
movl 0xf0(%rsp), %eax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1874
movl 0xf4(%rsp), %eax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
addl 0xf0(%rsp), %eax
movl %eax, 0xec(%rsp)
movl 0xf4(%rsp), %eax
imull 0x13c(%rsp), %eax
addl 0xf0(%rsp), %eax
movl %eax, 0xe8(%rsp)
movl 0xf4(%rsp), %eax
imull 0x13c(%rsp), %eax
addl 0xf0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
movl 0x118(%rsp), %eax
movq 0x130(%rsp), %rcx
movslq 0xf4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xf0(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x138(%rsp), %ecx
addl %ecx, %eax
movq 0x130(%rsp), %rcx
movslq 0xf4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0xf0(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, 0xe0(%rsp)
movl 0x118(%rsp), %eax
movq 0x130(%rsp), %rcx
movslq 0xf4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0xf0(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x138(%rsp), %ecx
addl %ecx, %eax
movq 0x130(%rsp), %rcx
movslq 0xf4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xf0(%rsp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, 0xdc(%rsp)
movq 0xf8(%rsp), %rax
movl 0xec(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xe8(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xec(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xe4(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xec(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xe0(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xec(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xdc(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movl 0xf0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf0(%rsp)
jmp 0x1630
jmp 0x1876
movl 0xf4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf4(%rsp)
jmp 0x1611
movl $0x0, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
movl 0x140(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1b26
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
cmpl 0x13c(%rsp), %eax
jge 0x1b0e
movl 0x120(%rsp), %eax
movl 0xd8(%rsp), %ecx
imull 0x13c(%rsp), %ecx
addl %ecx, %eax
addl 0xd4(%rsp), %eax
movl %eax, 0xd0(%rsp)
movl 0xd8(%rsp), %eax
imull 0x13c(%rsp), %eax
addl 0xd4(%rsp), %eax
movl %eax, 0xcc(%rsp)
movl 0xd8(%rsp), %eax
addl $0x1, %eax
imull 0x13c(%rsp), %eax
addl 0xd4(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0x140(%rsp), %eax
imull 0x13c(%rsp), %eax
movq 0x130(%rsp), %rcx
movslq 0xd8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xd4(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x138(%rsp), %ecx
addl %ecx, %eax
movq 0x130(%rsp), %rcx
movl 0xd8(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xd4(%rsp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, 0xc4(%rsp)
movl 0x140(%rsp), %eax
imull 0x13c(%rsp), %eax
movq 0x130(%rsp), %rcx
movl 0xd8(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xd4(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x138(%rsp), %ecx
addl %ecx, %eax
movq 0x130(%rsp), %rcx
movslq 0xd8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xd4(%rsp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, 0xc0(%rsp)
movq 0xf8(%rsp), %rax
movl 0xd0(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xcc(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xd0(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xc8(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xd0(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xc4(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movq 0xf8(%rsp), %rax
movl 0xd0(%rsp), %ecx
movl 0x140(%rsp), %edx
imull 0x13c(%rsp), %edx
movl 0x138(%rsp), %esi
imull 0x138(%rsp), %esi
addl %esi, %edx
imull %edx, %ecx
addl 0xc0(%rsp), %ecx
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x18bb
jmp 0x1b10
movl 0xd8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd8(%rsp)
jmp 0x1897
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2500
movq 0x28(%rsp), %rdi
movl 0x110(%rsp), %esi
movl 0x10c(%rsp), %edx
movl 0x108(%rsp), %ecx
movq 0xf8(%rsp), %r8
callq 0x26f0
jmp 0x1b61
leaq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1f00
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1f10
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x2fe0
jmp 0x1ba3
leaq 0x80(%rsp), %rdi
callq 0x1f20
cmpq $0x1, %rax
jne 0x1e98
movl 0x140(%rsp), %eax
movl 0x13c(%rsp), %ecx
imull %ecx, %eax
movslq %eax, %rdi
callq 0x1030
movq %rax, 0x10(%rsp)
jmp 0x1bda
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x1c5d
leaq 0x4428(%rip), %rdi      # 0x601b
xorl %eax, %eax
callq 0x1040
jmp 0x1bfc
movl $0x1, 0x144(%rsp)
movl $0x1, 0x5c(%rsp)
jmp 0x1eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1ed1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1fa0
leaq 0x80(%rsp), %rdi
callq 0x2000
jmp 0x1ed1
movl $0x0, 0x58(%rsp)
movslq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1f20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1e96
movl $0x0, 0x54(%rsp)
movslq 0x54(%rsp), %rax
movq %rax, (%rsp)
movslq 0x58(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x1f40
movq %rax, %rdi
callq 0x1f60
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1dfb
movslq 0x58(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x1f40
movq %rax, %rdi
movslq 0x54(%rsp), %rsi
callq 0x1f80
movl (%rax), %eax
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
movl 0x140(%rsp), %ecx
movl 0x13c(%rsp), %edx
subl $0x1, %edx
imull %edx, %ecx
cmpl %ecx, %eax
jge 0x1d70
movl 0x50(%rsp), %eax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
cltd
idivl %ecx
movl %eax, 0x4c(%rsp)
movl 0x50(%rsp), %eax
movl 0x13c(%rsp), %ecx
subl $0x1, %ecx
cltd
idivl %ecx
movl %edx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movl 0x4c(%rsp), %ecx
imull 0x13c(%rsp), %ecx
addl 0x48(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq 0x60(%rsp), %rax
movl 0x4c(%rsp), %ecx
imull 0x13c(%rsp), %ecx
addl 0x48(%rsp), %ecx
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
jmp 0x1de9
movl 0x140(%rsp), %ecx
movl 0x13c(%rsp), %eax
subl $0x1, %eax
imull %eax, %ecx
movl 0x50(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
cltd
idivl 0x13c(%rsp)
movl %eax, 0x44(%rsp)
movl 0x50(%rsp), %eax
cltd
idivl 0x13c(%rsp)
movl %edx, 0x40(%rsp)
movq 0x60(%rsp), %rax
movl 0x44(%rsp), %ecx
addl $0x1, %ecx
imull 0x13c(%rsp), %ecx
addl 0x40(%rsp), %ecx
movslq %ecx, %rcx
movb $0x7c, (%rax,%rcx)
movq 0x60(%rsp), %rax
movl 0x44(%rsp), %ecx
imull 0x13c(%rsp), %ecx
addl 0x40(%rsp), %ecx
movslq %ecx, %rcx
movb $0x7c, (%rax,%rcx)
jmp 0x1deb
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1c95
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x140(%rsp), %eax
jge 0x1e84
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x13c(%rsp), %eax
jge 0x1e65
movq 0x60(%rsp), %rax
movslq 0x38(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x4214(%rip), %rdi      # 0x6056
xorl %eax, %eax
callq 0x1040
jmp 0x1e4b
jmp 0x1e4d
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1e20
leaq 0x41e8(%rip), %rdi      # 0x6054
xorl %eax, %eax
callq 0x1040
jmp 0x1e75
jmp 0x1e77
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1e0b
jmp 0x1e86
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x1c65
jmp 0x1e98
movl $0x0, 0x144(%rsp)
movl $0x1, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1fa0
leaq 0x80(%rsp), %rdi
callq 0x2000
leaq 0xa8(%rsp), %rdi
callq 0x2590
jmp 0x1ee0
leaq 0xa8(%rsp), %rdi
callq 0x2590
jmp 0x1eef
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
movq 0xa0(%rsp), %rdi
callq 0x1140
nopl (%rax)