LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: M
sv M(gf o,const gf a,const gf b)
{
  i64 i,j,t[31];
  FOR(i,31) t[i]=0;
  FOR(i,16) FOR(j,16) t[i+j]+=a[i]*b[j];
  FOR(i,15) t[i]+=38*t[i+16];
  FOR(i,16) o[i]=t[i];
  car25519(o);
  car25519(o);
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x1f, %rax
je 0x203c
andq $0x0, (%rsp,%rax,8)
incq %rax
jmp 0x202c
movq %rsp, %rax
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x206e
movq (%rsi,%rcx,8), %rdi
xorl %r8d, %r8d
cmpq $0x10, %r8
je 0x2065
movq (%rdx,%r8,8), %r9
imulq %rdi, %r9
addq %r9, (%rax,%r8,8)
incq %r8
jmp 0x204e
incq %rcx
addq $0x8, %rax
jmp 0x2041
xorl %eax, %eax
cmpq $0xf, %rax
je 0x2088
imulq $0x26, 0x80(%rsp,%rax,8), %rcx
addq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x2070
xorl %eax, %eax
cmpq $0x10, %rax
je 0x209d
movq (%rsp,%rax,8), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
jmp 0x208a
movq %rbx, %rdi
callq 0x313f
movq %rbx, %rdi
addq $0x100, %rsp            # imm = 0x100
popq %rbx
jmp 0x313f
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: inv25519
sv inv25519(gf o,const gf i)
{
  gf c;
  int a;
  FOR(a,16) c[a]=i[a];
  for(a=253;a>=0;a--) {
    S(c,c);
    if(a!=2&&a!=4) M(c,c,i);
  }
  FOR(a,16) o[a]=c[a];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x20dd
movq (%r14,%rax,8), %rcx
movq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x20ca
movl $0xfd, %ebp
movq %rsp, %r15
testl %ebp, %ebp
js 0x2110
movq %r15, %rdi
movq %r15, %rsi
callq 0x201a
cmpl $0x2, %ebp
je 0x210c
cmpl $0x4, %ebp
je 0x210c
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x201f
decl %ebp
jmp 0x20e5
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2125
movq (%rsp,%rax,8), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
jmp 0x2112
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack25519
sv pack25519(u8 *o,const gf n)
{
  int i,j,b;
  gf m,t;
  FOR(i,16) t[i]=n[i];
  car25519(t);
  car25519(t);
  car25519(t);
  FOR(j,2) {
    m[0]=t[0]-0xffed;
    for(i=1;i<15;i++) {
      m[i]=t[i]-0xffff-((m[i-1]>>16)&1);
      m[i-1]&=0xffff;
    }
    m[15]=t[15]-0x7fff-((m[14]>>16)&1);
    b=(m[15]>>16)&1;
    m[14]&=0xffff;
    sel25519(t,m,1-b);
  }
  FOR(i,16) {
    o[2*i]=t[i]&0xff;
    o[2*i+1]=t[i]>>8;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2160
movq (%rsi,%rax,8), %rcx
movq %rcx, 0x80(%rsp,%rax,8)
incq %rax
jmp 0x2149
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x313f
movq %r14, %rdi
callq 0x313f
movq %r14, %rdi
callq 0x313f
xorl %ebp, %ebp
movq $-0xffed, %r12          # imm = 0xFFFF0013
pushq $0x1
popq %r13
movq %rsp, %r15
cmpl $0x2, %ebp
je 0x2222
movq 0x80(%rsp), %rcx
addq %r12, %rcx
movq %rcx, (%rsp)
movq %r13, %rax
cmpq $0xf, %rax
je 0x21dc
movq 0x80(%rsp,%rax,8), %rdx
movzwl %cx, %esi
shlq $0x2f, %rcx
sarq $0x3f, %rcx
addq %rdx, %rcx
addq $-0xffff, %rcx          # imm = 0xFFFF0001
movq %rcx, (%rsp,%rax,8)
movq %rsi, -0x8(%rsp,%rax,8)
incq %rax
jmp 0x21ab
movq 0xf8(%rsp), %rax
movq 0x70(%rsp), %rcx
movzwl %cx, %edx
shlq $0x2f, %rcx
sarq $0x3f, %rcx
addq %rcx, %rax
addq $-0x7fff, %rax          # imm = 0x8001
movq %rax, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
xorl %edx, %edx
btl $0x10, %eax
setae %dl
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fba
incl %ebp
jmp 0x2190
xorl %eax, %eax
cmpq $0x10, %rax
je 0x223b
movzwl 0x80(%rsp,%rax,8), %ecx
movw %cx, (%rbx,%rax,2)
incq %rax
jmp 0x2224
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_hash_sha512_tweet
int crypto_hash(u8 *out,const u8 *m,u64 n)
{
  u8 h[64],x[256];
  u64 i,b = n;

  FOR(i,64) h[i] = iv[i];

  crypto_hashblocks(h,m,n);
  m += n;
  n &= 127;
  m -= n;

  FOR(i,256) x[i] = 0;
  FOR(i,n) x[i] = m[i];
  x[n] = 128;

  n = 256-128*(n<112);
  x[n-9] = b >> 61;
  ts64(x+n-8,b<<3);
  crypto_hashblocks(h,x,n);

  FOR(i,64) out[i] = h[i];

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x1db9(%rip), %rcx      # 0x43c0
cmpq $0x40, %rax
je 0x2618
movb (%rax,%rcx), %dl
movb %dl, (%rsp,%rax)
incq %rax
jmp 0x2607
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x236b
movl %r14d, %eax
andl $0x7f, %eax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x2641
movb $0x0, 0x40(%rsp,%rcx)
incq %rcx
jmp 0x262e
movq %r14, %rcx
andq $-0x80, %rcx
addq %rcx, %r15
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x265f
movb (%r15,%rcx), %dl
movb %dl, 0x40(%rsp,%rcx)
incq %rcx
jmp 0x264d
movb $-0x80, 0x40(%rsp,%rax)
xorl %ecx, %ecx
cmpq $0x70, %rax
setae %cl
shll $0x7, %ecx
leaq 0x80(%rcx), %r15
movq %r14, %rax
shrq $0x3d, %rax
leaq 0x40(%rsp), %r12
movb %al, 0x77(%rcx,%r12)
leaq (%rsp,%rcx), %rdi
addq $0xb8, %rdi
shlq $0x3, %r14
movq %r14, %rsi
callq 0x25d1
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x236b
xorl %eax, %eax
cmpq $0x40, %rax
je 0x26c0
movb (%rsp,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x26af
xorl %eax, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_sign_ed25519_tweet_keypair
int crypto_sign_keypair(u8 *pk, u8 *sk)
{
  u8 d[64];
  gf p[4];
  int i;

  randombytes(sk, 32);
  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  scalarbase(p,d);
  pack(pk,p);

  FOR(i,32) sk[32 + i] = pk[i];
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x123c
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x25e7
andb $-0x8, (%r12)
movb 0x1f(%r12), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%r12)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2759
movq %r14, %rdi
movq %r15, %rsi
callq 0x27e1
xorl %eax, %eax
cmpq $0x20, %rax
je 0x2748
movb (%r14,%rax), %cl
movb %cl, 0x20(%rbx,%rax)
incq %rax
jmp 0x2735
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: scalarbase
sv scalarbase(gf p[4],const u8 *s)
{
  gf q[4];
  set25519(q[0],X);
  set25519(q[1],Y);
  set25519(q[2],gf1);
  M(q[3],X,Y);
  scalarmult(p,q,s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d2a(%rip), %r15      # 0x44a0
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3196
leaq 0x80(%rsp), %rdi
leaq 0x1d8d(%rip), %r13      # 0x4520
movq %r13, %rsi
callq 0x3196
leaq 0x100(%rsp), %rdi
leaq 0x1df6(%rip), %rsi      # 0x45a0
callq 0x3196
leaq 0x180(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x201f
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2ec3
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack
sv pack(u8 *r,gf p[4])
{
  gf tx, ty, zi;
  inv25519(zi, p[2]); 
  M(tx, p[0], zi);
  M(ty, p[1], zi);
  pack25519(r, ty);
  r[31] ^= par25519(tx) << 7;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
addq $0x100, %rsi            # imm = 0x100
movq %rsp, %r15
movq %r15, %rdi
callq 0x20b5
leaq 0x100(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x201f
subq $-0x80, %r14
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x201f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2133
movq %r12, %rdi
callq 0x31ac
shlb $0x7, %al
xorb %al, 0x1f(%rbx)
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_sign_ed25519_tweet
int crypto_sign(u8 *sm,u64 *smlen,const u8 *m,u64 n,const u8 *sk)
{
  u8 d[64],h[64],r[64];
  i64 i,j,x[64];
  gf p[4];

  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  *smlen = n+64;
  FOR(i,n) sm[64 + i] = m[i];
  FOR(i,32) sm[32 + i] = d[32 + i];

  crypto_hash(r, sm+32, n+32);
  reduce(r);
  scalarbase(p,r);
  pack(sm,p);

  FOR(i,32) sm[i+32] = sk[i+32];
  crypto_hash(h,sm,n + 64);
  reduce(h);

  FOR(i,64) x[i] = 0;
  FOR(i,32) x[i] = (u64) r[i];
  FOR(i,32) FOR(j,32) x[i+j] += h[i] * (u64) d[j];
  modL(sm + 32,x);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x10(%rsp), %r12
pushq $0x20
popq %rbx
movq %r12, %rdi
movq %r8, %rsi
movq %rbx, %rdx
callq 0x25e7
andb $-0x8, (%r12)
movb 0x1f(%r12), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%r12)
leaq 0x40(%r13), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
cmpq %rax, %r13
je 0x28dd
movb (%rbp,%rax), %cl
movb %cl, 0x40(%r14,%rax)
incq %rax
jmp 0x28bf
movb 0x10(%rsp,%rbx), %al
movb %al, (%r14,%rbx)
incq %rbx
cmpq $0x40, %rbx
jne 0x28d2
leaq 0x20(%r14), %rbx
addq $0x20, %r13
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x25e7
movq %r12, %rdi
callq 0x29e9
leaq 0x2d0(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2759
movq %r14, %rdi
movq %r13, %rsi
callq 0x27e1
pushq $0x20
popq %rax
cmpq $0x40, %rax
je 0x293a
movb (%r15,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x2927
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x25e7
movq %r15, %rdi
callq 0x29e9
xorl %eax, %eax
cmpq $0x40, %rax
je 0x2970
andq $0x0, 0xd0(%rsp,%rax,8)
incq %rax
jmp 0x295c
xorl %eax, %eax
cmpq $0x20, %rax
je 0x298a
movzbl 0x50(%rsp,%rax), %ecx
movq %rcx, 0xd0(%rsp,%rax,8)
incq %rax
jmp 0x2972
leaq 0xd0(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x29c5
movzbl 0x90(%rsp,%rcx), %edx
xorl %esi, %esi
cmpq $0x20, %rsi
je 0x29bc
movzbl 0x10(%rsp,%rsi), %edi
imulq %rdx, %rdi
addq %rdi, (%rax,%rsi,8)
incq %rsi
jmp 0x29a4
incq %rcx
addq $0x8, %rax
jmp 0x2994
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a26
xorl %eax, %eax
addq $0x4d8, %rsp            # imm = 0x4D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: modL
sv modL(u8 *r,i64 x[64])
{
  i64 carry,i,j;
  for (i = 63;i >= 32;--i) {
    carry = 0;
    for (j = i - 32;j < i - 12;++j) {
      x[j] += carry - 16 * x[i] * L[j - (i - 32)];
      carry = (x[j] + 128) >> 8;
      x[j] -= carry << 8;
    }
    x[j] += carry;
    x[i] = 0;
  }
  carry = 0;
  FOR(j,32) {
    x[j] += carry - (x[31] >> 4) * L[j];
    carry = x[j] >> 8;
    x[j] &= 255;
  }
  FOR(j,32) x[j] -= carry * L[j];
  FOR(i,32) {
    x[i+1] += x[i] >> 8;
    r[i] = x[i] & 255;
  }
}

// Assembly:
pushq %rbx
leaq 0xf8(%rsi), %rcx
movabsq $0x3f, %rdx
movabsq $0x33, %r8
leaq 0x1bd7(%rip), %rax      # 0x4620
cmpq $0x1f, %rdx
jbe 0x2ab0
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq $0xa0, %r9
je 0x2a9b
movq (%rsi,%rdx,8), %r11
imulq (%r9,%rax), %r11
shlq $0x4, %r11
subq %r11, %r10
movq (%rcx,%r9), %r11
leaq (%r10,%r11), %rbx
addq %r10, %r11
addq $0x80, %r11
movq %r11, %r10
sarq $0x8, %r10
andq $-0x100, %r11
subq %r11, %rbx
movq %rbx, (%rcx,%r9)
addq $0x8, %r9
jmp 0x2a55
addq %r10, (%rsi,%r8,8)
andq $0x0, (%rsi,%rdx,8)
decq %rdx
decq %r8
addq $-0x8, %rcx
jmp 0x2a49
xorl %edx, %edx
xorl %ecx, %ecx
cmpq $0x100, %rdx            # imm = 0x100
je 0x2ae6
movq 0xf8(%rsi), %r8
sarq $0x4, %r8
imulq (%rdx,%rax), %r8
subq %r8, %rcx
addq (%rsi,%rdx), %rcx
movzbl %cl, %r8d
sarq $0x8, %rcx
movq %r8, (%rsi,%rdx)
addq $0x8, %rdx
jmp 0x2ab4
xorl %edx, %edx
cmpq $0x100, %rdx            # imm = 0x100
je 0x2b03
movq (%rdx,%rax), %r8
imulq %rcx, %r8
subq %r8, (%rsi,%rdx)
addq $0x8, %rdx
jmp 0x2ae8
xorl %eax, %eax
cmpq $0x20, %rax
je 0x2b23
movq (%rsi,%rax,8), %rcx
movq %rcx, %rdx
sarq $0x8, %rdx
addq %rdx, 0x8(%rsi,%rax,8)
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x2b05
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: scalarmult
sv scalarmult(gf p[4],gf q[4],const u8 *s)
{
  int i;
  set25519(p[0],gf0);
  set25519(p[1],gf1);
  set25519(p[2],gf1);
  set25519(p[3],gf0);
  for (i = 255;i >= 0;--i) {
    u8 b = (s[i/8]>>(i&7))&1;
    cswap(p,q,b);
    add(q,p);
    add(p,p);
    cswap(p,q,b);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1942(%rip), %r12      # 0x4820
movq %r12, %rsi
callq 0x3196
leaq 0x80(%r15), %rdi
leaq 0x16ac(%rip), %r13      # 0x45a0
movq %r13, %rsi
callq 0x3196
leaq 0x100(%r15), %rdi
movq %r13, %rsi
callq 0x3196
leaq 0x180(%r15), %rdi
movq %r12, %rsi
callq 0x3196
movl $0xff, %r12d
testl %r12d, %r12d
js 0x2f73
movl %r12d, %eax
shrl $0x3, %eax
movzbl (%rbx,%rax), %eax
movl %r12d, %ecx
andl $0x7, %ecx
xorl %ebp, %ebp
btl %ecx, %eax
setb %bpl
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3208
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f82
movq %r15, %rdi
movq %r15, %rsi
callq 0x2f82
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3208
decl %r12d
jmp 0x2f20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: add
sv add(gf p[4],gf q[4])
{
  gf a,b,c,d,t,e,f,g,h;
  
  Z(a, p[1], p[0]);
  Z(t, q[1], q[0]);
  M(a, a, t);
  A(b, p[0], p[1]);
  A(t, q[0], q[1]);
  M(b, b, t);
  M(c, p[3], q[3]);
  M(c, c, D2);
  M(d, p[2], q[2]);
  A(d, d, d);
  Z(e, b, a);
  Z(f, d, c);
  A(g, d, c);
  A(h, b, a);

  M(p[0], e, f);
  M(p[1], h, g);
  M(p[2], g, f);
  M(p[3], e, h);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp            # imm = 0x498
movq %rsi, %rbp
movq %rdi, %r14
movl $0x80, %r15d
leaq (%rdi,%r15), %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, 0x8(%rsp)
movq %r14, %rdx
callq 0x2000
addq %rbp, %r15
leaq 0x310(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2000
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x201f
leaq 0x110(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1fe6
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x1fe6
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x201f
movl $0x180, %edx            # imm = 0x180
leaq (%r14,%rdx), %rsi
movq %rsi, (%rsp)
addq %rbp, %rdx
leaq 0x410(%rsp), %r12
movq %r12, %rdi
callq 0x201f
leaq 0x1865(%rip), %rdx      # 0x48a0
movq %r12, %rdi
movq %r12, %rsi
callq 0x201f
movl $0x100, %eax            # imm = 0x100
leaq (%r14,%rax), %r15
addq %rax, %rbp
leaq 0x390(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x201f
movq %rbx, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x1fe6
leaq 0x90(%rsp), %rdi
movq %r13, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2000
leaq 0x290(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2000
leaq 0x210(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1fe6
leaq 0x190(%rsp), %rbx
movq %rbx, %rdi
leaq 0x110(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1fe6
movq %r14, %rdi
leaq 0x90(%rsp), %r14
movq %r14, %rsi
movq %rbp, %rdx
callq 0x201f
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x201f
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x201f
movq (%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x201f
addq $0x498, %rsp            # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: car25519
sv car25519(gf o)
{
  int i;
  i64 c;
  FOR(i,16) {
    o[i]+=(1LL<<16);
    c=o[i]>>16;
    o[(i+1)*(i<15)]+=c-1+37*(c-1)*(i==15);
    o[i]-=c<<16;
  }
}

// Assembly:
xorl %eax, %eax
movl $0x10000, %ecx          # imm = 0x10000
xorl %edx, %edx
cmpq $0x10, %rdx
je 0x3195
movq (%rdi,%rdx,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdi,%rdx,8)
movq %rsi, %r8
sarq $0x10, %r8
decq %r8
imulq $0x25, %r8, %r9
leaq 0x1(%rdx), %r10
cmpq $0xf, %rdx
cmovneq %rax, %r9
movq %r10, %r11
cmoveq %rax, %r11
addq (%rdi,%r11,8), %r8
addq %r9, %r8
movq %r8, (%rdi,%r11,8)
andq $-0x10000, %rsi         # imm = 0xFFFF0000
subq %rsi, (%rdi,%rdx,8)
movq %r10, %rdx
jmp 0x3148
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl-sigpair.c
// Function: output_key
void output_key(char filename[], unsigned char key[], int key_size) {
    // http://stackoverflow.com/a/8004250
    if (strcmp(filename, "-") != 0) {
        FILE *out = create_file(filename);
        fwrite(key, key_size, 1, out);
        fclose(out);
    } else {
        fwrite(bytes_to_hex(key, key_size), key_size * 2, 1, stdout);
        fputs("\n", stdout);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
cmpb $0x2d, (%rdi)
jne 0x325d
cmpb $0x0, 0x1(%rdi)
je 0x3283
callq 0x13d2
movq %rax, %r15
movslq %ebx, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1120
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
movq %r14, %rdi
movl %ebx, %esi
callq 0x1357
addl %ebx, %ebx
movslq %ebx, %rsi
movq 0x3d3f(%rip), %rbx      # 0x6fd8
movq (%rbx), %rcx
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1120
movq (%rbx), %rsi
leaq 0x166f(%rip), %rdi      # 0x4920
popq %rbx
popq %r14
popq %r15
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl-sigpair.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 3) error(2, "Expected 2 filenames as arguments");

    unsigned char public_key[crypto_sign_PUBLICKEYBYTES];
    unsigned char secret_key[crypto_sign_SECRETKEYBYTES];
    crypto_sign_keypair(public_key, secret_key);

    if (file_exists(argv[1])) errorf(1, "File <%s> exists", argv[1]);
    if (file_exists(argv[2])) errorf(1, "File <%s> exists", argv[2]);

    output_key(argv[1], public_key, crypto_sign_PUBLICKEYBYTES);
    output_key(argv[2], secret_key, crypto_sign_SECRETKEYBYTES);

    return 0;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
je 0x32d7
leaq 0x1653(%rip), %rsi      # 0x4922
pushq $0x2
popq %rdi
callq 0x12c4
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x26d1
movq 0x8(%rbx), %rdi
callq 0x140c
testl %eax, %eax
je 0x3304
movq 0x8(%rbx), %rdx
leaq 0x1648(%rip), %rsi      # 0x4944
pushq $0x1
popq %rdi
callq 0x1306
movq 0x10(%rbx), %rdi
callq 0x140c
testl %eax, %eax
je 0x3324
movq 0x10(%rbx), %rdx
leaq 0x1628(%rip), %rsi      # 0x4944
pushq $0x1
popq %rdi
callq 0x1306
movq 0x8(%rbx), %rdi
movq %rsp, %rsi
pushq $0x20
popq %rdx
callq 0x3248
movq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x40
popq %rdx
callq 0x3248
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/bloques.c
// Function: bmount
int bmount (const char *camino) { 
	fichero = open(camino, O_RDWR|O_CREAT, 0666); 
	if(fichero < 0) printf("Error en la apertura del dispostivo\n");
	mutex = initSem();
	return fichero;
}

// Assembly:
pushq %rax
pushq $0x42
popq %rsi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1140
movl %eax, 0x5e46(%rip)      # 0x70d8
testl %eax, %eax
jns 0x12a2
leaq 0x2d67(%rip), %rdi      # 0x4004
callq 0x1060
xorl %eax, %eax
callq 0x3b8c
movq %rax, 0x5e30(%rip)      # 0x70e0
movl 0x5e22(%rip), %eax      # 0x70d8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: initSB
int initSB (unsigned int bloques, unsigned int inodos) { 
	struct superbloque sb; //Definimos la zona de memoria (variable de tipo superbloque)
	sb.posPrimerBloqueMB = posSB+1;
	sb.posUltimoBloqueMB = sb.posPrimerBloqueMB+tamMB(bloques)-1;
	sb.posPrimerBloqueAI = sb.posUltimoBloqueMB+1;
	sb.posUltimoBloqueAI = sb.posPrimerBloqueAI+tamAI(inodos)-1;
	sb.posPrimerBloqueDatos = sb.posUltimoBloqueAI+1;
	sb.posUltimoBloqueDatos = bloques-1;
	sb.posInodoRaiz = 0;
	sb.posPrimerInodoLibre = 0;
	sb.cantBloquesLibres = bloques;
	sb.cantInodosLibres = inodos;
	sb.totBloques = bloques;
	sb.totInodos = inodos;
	
	if(bwrite(posSB,&sb) < 0) return -1; //Error BWRITE	
	return 0;
}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
movl %esi, %eax
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movl %edi, %ecx
andl $0x1ff8, %ecx           # imm = 0x1FF8
movl %edi, %edx
shrl $0xd, %edx
cmpl $0x1, %ecx
sbbl $-0x1, %edx
leal 0x1(%rdx), %ecx
movl %edx, 0x4(%rsi)
movl %ecx, 0x8(%rsi)
movl %eax, %ecx
andl $0x7, %ecx
movl %eax, %r8d
shrl $0x3, %r8d
andl $0x3fffff, %r8d         # imm = 0x3FFFFF
cmpl $0x1, %ecx
sbbl $-0x1, %r8d
leal (%rdx,%r8), %ecx
incl %ecx
addl %edx, %r8d
movl %r8d, 0xc(%rsi)
movl %ecx, 0x10(%rsi)
leal -0x1(%rdi), %ecx
movl %ecx, 0x14(%rsi)
andq $0x0, 0x18(%rsi)
movl %edi, 0x20(%rsi)
movl %eax, 0x24(%rsi)
movl %edi, 0x28(%rsi)
movl %eax, 0x2c(%rsi)
xorl %edi, %edi
callq 0x12e3
sarl $0x1f, %eax
addq $0x408, %rsp            # imm = 0x408
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: initMB
int initMB (unsigned int bloques) { 
	struct superbloque sb;
	if(bread(posSB,&sb) < 0) return -1; //Leemos el superbloque para localizar el mapa de bits Error BREAD
	 
	unsigned char buf[tamBloque];
	memset(buf,0,tamBloque); //Definimos el array del tamanyo de un bloque con todos los bits a cero
	
	unsigned int bucle;
	for (bucle = sb.posPrimerBloqueMB; bucle <= sb.posUltimoBloqueMB; bucle++){
		if(bwrite(bucle,buf) < 0) return -2; //Error BWRITE
	}
	
	for(bucle = posSB; bucle <= sb.posUltimoBloqueAI; bucle++){
		if(escribir_bit(bucle,1) < 0) return -3; //Error ESCRIBIR_BIT
		sb.cantBloquesLibres--; //Restaremos los bloques (SB, MB, AI) de la cantidad de bloques libres
	} 
	
	if(bwrite(posSB,&sb) < 0) return -2; //Error BWRITE
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1463
leaq 0x400(%rsp), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movl (%rsp), %ebp
pushq $-0x2
popq %rbx
cmpl 0x4(%rsp), %ebp
ja 0x1468
movl %ebp, %edi
movq %r14, %rsi
callq 0x12e3
incl %ebp
testl %eax, %eax
jns 0x144b
jmp 0x149f
pushq $-0x1
popq %rbx
jmp 0x149f
xorl %ebp, %ebp
pushq $0x1
popq %r14
pushq $-0x3
popq %rbx
cmpl 0xc(%rsp), %ebp
ja 0x148d
movl %ebp, %edi
movl %r14d, %esi
callq 0x14ad
testl %eax, %eax
js 0x149f
decl 0x20(%rsp)
incl %ebp
jmp 0x1471
movq %rsp, %rsi
xorl %edi, %edi
callq 0x12e3
movl %eax, %ebx
sarl $0x1f, %ebx
andl $-0x2, %ebx
movl %ebx, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: escribir_bit
int escribir_bit (unsigned int bloque, unsigned int bit) { 
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) return -1; //Leemos el superbloque para localizar el mapa de bits Error BREADS
	
	int posbyte = bloque/8, posbit = bloque%8;
	int MB = (posbyte/tamBloque) + sb.posPrimerBloqueMB; //Bloque cuyo bit actualizaremos
	posbyte %= tamBloque; //Para que se ajuste a un bloque
		
	unsigned char mapaBits[tamBloque];
	if(bread(MB,mapaBits) < 0) return -2; // Error BREADMB
	
	unsigned char mascara = 128; //10000000
	mascara >>= posbit; //Desplazamiento de bits a la derecha
	if(bit == 0) {
		mapaBits[posbyte]&=~mascara; //AND y NOT para bits
	} else { //bit == 1
		mapaBits[posbyte]|=mascara; //OR para bits
	}
	if(bwrite(MB,mapaBits) < 0) return -3; //Error BWRITE;
	return 0;		
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movl %esi, %ebx
movl %edi, %r14d
leaq 0x400(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1536
movl %r14d, %ebp
shrl $0xd, %ebp
addl 0x400(%rsp), %ebp
movq %rsp, %rsi
movl %ebp, %edi
callq 0x1319
testl %eax, %eax
js 0x153a
movl %r14d, %eax
shrl $0x3, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movb (%rsp,%rax), %dl
andb $0x7, %r14b
movl $0x80, %esi
movl %r14d, %ecx
shrl %cl, %esi
movl $0xffffff7f, %edi       # imm = 0xFFFFFF7F
sarl %cl, %edi
orb %dl, %sil
andb %dl, %dil
testl %ebx, %ebx
movzbl %dil, %ecx
movzbl %sil, %edx
cmovel %ecx, %edx
movb %dl, (%rsp,%rax)
movq %rsp, %rsi
movl %ebp, %edi
callq 0x12e3
sarl $0x1f, %eax
andl $-0x3, %eax
jmp 0x153d
pushq $-0x1
jmp 0x153c
pushq $-0x2
popq %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: initAI
int initAI (unsigned int inodos) { 
	struct superbloque sb;
	if(bread(posSB,&sb) < 0) return -1; //Leemos el superbloque para localizar el mapa de bits Error BREAD
	
	struct inodo in[tamBloque/tamInodo];
	unsigned int x, i, j;
	x = 1;
	for(i = sb.posPrimerBloqueAI; i <= sb.posUltimoBloqueAI; i++) {
		for(j = 0; j < tamBloque/tamInodo; j++) {
			in[j].tipo = 'l';
			if(x < inodos) {
				in[j].punterosDirectos[0] = x;
				x++;
			} else {
				in[j].punterosDirectos[0] = UINT_MAX;
				j = tamBloque/tamInodo;
			}
		}
		if(bwrite(i,&in) < 0) return -2; //Escribimos el array de inodos Error BWRITE
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl %edi, %ebx
leaq 0x408(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x15d6
pushq $0x1
popq %r12
movl 0x410(%rsp), %r14d
pushq $-0x1
popq %r13
pushq $0x9
popq %rbp
movq %rsp, %r15
cmpl 0x414(%rsp), %r14d
ja 0x15db
xorl %eax, %eax
cmpl $0x7, %eax
ja 0x15c0
cmpl %ebx, %r12d
movl %r12d, %ecx
adcl $0x0, %ecx
cmpl %ebx, %r12d
movl %eax, %edx
cmovael %r13d, %r12d
leal 0x1(%rax), %eax
cmovael %ebp, %eax
shlq $0x7, %rdx
movb $0x6c, (%rsp,%rdx)
movl %r12d, 0x2c(%rsp,%rdx)
movl %ecx, %r12d
jmp 0x1591
movl %r14d, %edi
movq %r15, %rsi
callq 0x12e3
incl %r14d
testl %eax, %eax
jns 0x1585
pushq $-0x2
jmp 0x15d8
pushq $-0x1
popq %rax
jmp 0x15dd
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: leerSB
int leerSB (){
	struct superbloque sb;
	if(bread(posSB,&sb) < 0) return -1; //Leemos el superbloque para localizar el mapa de bits Error BREAD
	printf("--------Información SUPERBLOQUE---------\n");
	printf("Primer Bloque MB: %d\n", sb.posPrimerBloqueMB);
	printf("Ultimo Bloque MB: %d\n", sb.posUltimoBloqueMB);
	printf("Primer Bloque AI: %d\n", sb.posPrimerBloqueAI);
	printf("Ultimo Bloque AI: %d\n", sb.posUltimoBloqueAI);
	printf("Primer Bloque Datos: %d\n", sb.posPrimerBloqueDatos);
	printf("Ultimo Bloque Datos: %d\n", sb.posUltimoBloqueDatos);
	printf("Posición Inodo Raiz: %d\n", sb.posInodoRaiz);
	printf("Primer Inodo Libre: %d\n", sb.posPrimerInodoLibre);
	printf("Cantidad Bloques Libres: %d\n", sb.cantBloquesLibres);
	printf("Cantidad Inodos Libres: %d\n", sb.cantInodosLibres);
	printf("Cantidad Bloques Totales: %d\n", sb.totBloques);
	printf("Cantidad Inodos Totales: %d\n", sb.totInodos);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
xorl %ebx, %ebx
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x16f0
leaq 0x2bf9(%rip), %rdi      # 0x420b
callq 0x1060
movl (%rsp), %esi
leaq 0x2a2b(%rip), %rdi      # 0x404c
xorl %eax, %eax
callq 0x1090
movl 0x4(%rsp), %esi
leaq 0x2a2f(%rip), %rdi      # 0x4062
xorl %eax, %eax
callq 0x1090
movl 0x8(%rsp), %esi
leaq 0x2a33(%rip), %rdi      # 0x4078
xorl %eax, %eax
callq 0x1090
movl 0xc(%rsp), %esi
leaq 0x2a37(%rip), %rdi      # 0x408e
xorl %eax, %eax
callq 0x1090
movl 0x10(%rsp), %esi
leaq 0x2a3b(%rip), %rdi      # 0x40a4
xorl %eax, %eax
callq 0x1090
movl 0x14(%rsp), %esi
leaq 0x2a42(%rip), %rdi      # 0x40bd
xorl %eax, %eax
callq 0x1090
movl 0x18(%rsp), %esi
leaq 0x2a49(%rip), %rdi      # 0x40d6
xorl %eax, %eax
callq 0x1090
movl 0x1c(%rsp), %esi
leaq 0x2a51(%rip), %rdi      # 0x40f0
xorl %eax, %eax
callq 0x1090
movl 0x20(%rsp), %esi
leaq 0x2a57(%rip), %rdi      # 0x4108
xorl %eax, %eax
callq 0x1090
movl 0x24(%rsp), %esi
leaq 0x2a62(%rip), %rdi      # 0x4125
xorl %eax, %eax
callq 0x1090
movl 0x28(%rsp), %esi
leaq 0x2a6c(%rip), %rdi      # 0x4141
xorl %eax, %eax
callq 0x1090
movl 0x2c(%rsp), %esi
leaq 0x2a78(%rip), %rdi      # 0x415f
xorl %eax, %eax
callq 0x1090
jmp 0x16f3
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: leer_bit
unsigned char leer_bit (unsigned int bloque) {
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) return -1; //Leemos el superbloque para localizar el mapa de bits Error BREADS
	
	int posbyte = bloque/8, posbit = bloque%8;
	int MB = (posbyte/tamBloque) + sb.posPrimerBloqueMB; //Bloque cuyo bit actualizaremos
	posbyte %= tamBloque; //Para que se ajuste a un bloque
		
	unsigned char mapaBits[tamBloque];
	if(bread(MB,mapaBits) < 0) return -2; // Error BREADMB
	
	unsigned char mascara = 128; //10000000
	mascara >>= posbit; //Desplazamiento de bits a la derecha
	mascara &= mapaBits[posbyte]; //Operador AND para bits
	mascara >>= (7-posbit); //Desplazamiento de bits a la derecha
	return mascara; //0 o 1
}

// Assembly:
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movl %edi, %ebx
leaq 0x400(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1758
movl %ebx, %edi
shrl $0xd, %edi
addl 0x400(%rsp), %edi
movq %rsp, %rsi
callq 0x1319
testl %eax, %eax
js 0x175c
movl %ebx, %eax
shrl $0x3, %eax
andb $0x7, %bl
movl $0x80, %edx
movl %ebx, %ecx
shrl %cl, %edx
andl $0x3ff, %eax            # imm = 0x3FF
movzbl (%rsp,%rax), %eax
andl %edx, %eax
xorb $0x7, %bl
movl %ebx, %ecx
shrl %cl, %eax
jmp 0x175e
movb $-0x1, %al
jmp 0x175e
movb $-0x2, %al
addq $0x800, %rsp            # imm = 0x800
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: reservar_bloque
int reservar_bloque () { 
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) return -1; //Error BREADS
	if(sb.cantBloquesLibres <= 0) return -2; //Error NO_BLOQUES_LIBRES
	unsigned char bufferAux[tamBloque];
	memset(bufferAux,255,tamBloque);
	unsigned char mapaBits[tamBloque];
	int nMB = sb.posPrimerBloqueMB;
	
	if(bread(nMB, mapaBits) < 0) return -3; //Error BREADMB
	
	while(memcmp(bufferAux,mapaBits,tamBloque) == 0){   					
		nMB++;
		if(bread(nMB, mapaBits) < 0) return -3; //Error BREADMB    
	}
	
	unsigned char byte = 255;
	unsigned char mascara = 128;
	int posbyte = 0, posbit = 0, fin = 0;
	while(posbyte < tamBloque && !fin){ 
		byte = mapaBits[posbyte];
		if (byte < 255) { // hay bits a 0 en el byte
			while (byte & mascara) { // operador AND para bits
				byte <<= 1;	// desplazamiento de bits a la izquierda
				posbit++;
			}
            fin = 1;
		} else posbyte++; // si el byte no contiene 0s vamos al siguiente
	}
	int numbloque = ((nMB-sb.posPrimerBloqueMB)*tamBloque+posbyte)*8+posbit;
	if(escribir_bit(numbloque, 1) < 0) return -4; //Error ESCRIBIR_BIT
	sb.cantBloquesLibres--;
	if (bwrite(posSB, &sb) < 0) return -5; //Error BWRITE
		
	return numbloque; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc00, %rsp            # imm = 0xC00
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1801
cmpl $0x0, 0x20(%rsp)
je 0x1805
leaq 0x800(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
movl $0xff, %esi
callq 0x10b0
movl (%rsp), %ebp
leaq 0x400(%rsp), %rsi
movl %ebp, %edi
callq 0x1319
pushq $-0x3
popq %rbx
testl %eax, %eax
js 0x1808
movl %ebp, %r12d
shll $0xd, %r12d
incl %ebp
leaq 0x800(%rsp), %r14
leaq 0x400(%rsp), %r15
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %r15, %rsi
callq 0x1130
testl %eax, %eax
jne 0x181a
movl %ebp, %edi
movq %r15, %rsi
callq 0x1319
addl $0x2000, %r12d          # imm = 0x2000
incl %ebp
testl %eax, %eax
jns 0x17d4
jmp 0x1808
pushq $-0x1
jmp 0x1807
pushq $-0x2
popq %rbx
movl %ebx, %eax
addq $0xc00, %rsp            # imm = 0xC00
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
xorl %ecx, %ecx
xorl %ebx, %ebx
movl %ecx, %ecx
movb $0x1, %dl
cmpl $0x3ff, %ecx            # imm = 0x3FF
ja 0x1852
testb $0x1, %dl
je 0x1852
movb 0x400(%rsp,%rcx), %dl
cmpb $-0x1, %dl
jne 0x1843
jmp 0x184b
addb %dl, %dl
incl %ebx
testb %dl, %dl
js 0x183f
xorl %edx, %edx
jmp 0x1824
incl %ecx
addl $0x8, %eax
jmp 0x1820
movl (%rsp), %ecx
shll $0xd, %ecx
subl %ecx, %eax
addl %r12d, %ebx
addl %eax, %ebx
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x14ad
testl %eax, %eax
js 0x1884
movq %rsp, %rsi
decl 0x20(%rsi)
xorl %edi, %edi
callq 0x12e3
testl %eax, %eax
pushq $-0x5
popq %rax
cmovsl %eax, %ebx
jmp 0x1808
pushq $-0x4
jmp 0x1807
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: liberar_bloque
int liberar_bloque (unsigned int bloque) { 
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) return -1; //Error BREAD
	if(escribir_bit(bloque,0) < 0) return -2; //Error ESCRIBIR_BIT
	sb.cantBloquesLibres++;
	if(bwrite(posSB,&sb) < 0) return -3; //Error BWRITE
	return bloque;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x18c7
movl %ebx, %edi
xorl %esi, %esi
callq 0x14ad
testl %eax, %eax
js 0x18cb
movq %rsp, %rsi
incl 0x20(%rsi)
xorl %edi, %edi
callq 0x12e3
testl %eax, %eax
pushq $-0x3
popq %rax
cmovsl %eax, %ebx
jmp 0x18ce
pushq $-0x1
jmp 0x18cd
pushq $-0x2
popq %rbx
movl %ebx, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: escribir_inodo
int escribir_inodo(struct inodo inodo, unsigned int ninodo) {
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) return -1; //Error BREAD
	int posIN = ((ninodo*tamInodo)/tamBloque)+sb.posPrimerBloqueAI;
	struct inodo inodos[tamBloque/tamInodo];
	if(bread(posIN,&inodos) < 0) return -1; //Leemos el array de inodos Error BREAD
	int final = ninodo%(tamBloque/tamInodo);
	inodos[final] = inodo; 
	if(bwrite(posIN,&inodos) < 0) return -2; //Error BWRITE
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl %edi, %ebx
leaq 0x408(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1941
movl %ebx, %ebp
shrl $0x3, %ebp
andl $0x3fffff, %ebp         # imm = 0x3FFFFF
addl 0x410(%rsp), %ebp
movq %rsp, %rsi
movl %ebp, %edi
callq 0x1319
testl %eax, %eax
js 0x1941
leaq 0x820(%rsp), %rsi
andl $0x7, %ebx
shll $0x7, %ebx
leaq (%rsp,%rbx), %rdi
pushq $0x10
popq %rcx
rep  movsq (%rsi), %es:(%rdi)
movq %rsp, %rsi
movl %ebp, %edi
callq 0x12e3
sarl $0x1f, %eax
andl $-0x2, %eax
jmp 0x1944
pushq $-0x1
popq %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: leer_inodo
struct inodo leer_inodo(unsigned int inodo) {
	struct superbloque sb; 
	bread(posSB,&sb);
	int posIN = ((inodo*tamInodo)/tamBloque)+sb.posPrimerBloqueAI;
	struct inodo inodos[tamBloque/tamInodo];
	bread(posIN,&inodos); //Leemos el array de inodos
	return inodos[inodo%(tamBloque/tamInodo)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x400(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x1319
movl %r14d, %edi
shrl $0x3, %edi
andl $0x3fffff, %edi         # imm = 0x3FFFFF
addl 0x8(%r15), %edi
movq %rsp, %rsi
callq 0x1319
andl $0x7, %r14d
shll $0x7, %r14d
leaq (%rsp,%r14), %rsi
pushq $0x10
popq %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: reservar_inodo
int reservar_inodo (unsigned char tipo, unsigned char permisos) {
	struct superbloque sb; 
	if(bread(posSB,&sb) < 0) {
		puts("Error a la hora de leer el superbloque");
		return -1; //Error BREAD
	} 
	if(sb.cantInodosLibres == 0) {
		puts("No hay inodos libres");
		return -2; //Error NO_INODOS_LIBRES
	} 
	int posPIL = sb.posPrimerInodoLibre;
	
	struct inodo inodoR = leer_inodo(posPIL);
	
	//Modificamos el SuperBloque
	sb.posPrimerInodoLibre = inodoR.punterosDirectos[0];
	sb.cantInodosLibres--; //Al reservar un inodo, un inodo libre menos
	if(bwrite(posSB,&sb) < 0) {
		puts("Error a la hora de escribir en el superbloque");
		return -3; //Error BWRITE	
	}
	
	//Inicializamos el inodo
	inodoR.tipo = tipo;
	inodoR.permisos = permisos;
	inodoR.atime = time(NULL);
	inodoR.mtime = time(NULL);
	inodoR.ctime = time(NULL);
	inodoR.cantLinks = 1;
	inodoR.tamBytesLogicos = 0;
	inodoR.cantBloquesOcupados = 0;
	
	//Inicializamos los punteros
	int bucle;
	for(bucle = 0; bucle < puntD; bucle++) inodoR.punterosDirectos[bucle] = 0;
	for(bucle = 0; bucle < puntI; bucle++) inodoR.punterosIndirectos[bucle] = 0;
	if(escribir_inodo(inodoR,posPIL) < 0) {
		puts("Error a la hora de escribir el inodo");	
		return -4; //Escribimos el nuevo inodo Error ESCRIBIR_INODO
	}
	return posPIL; //Devolvemos le numero de inodo reservado
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x500, %rsp            # imm = 0x500
movl %esi, %ebp
movl %edi, %r14d
leaq 0x100(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1a8c
cmpl $0x0, 0x124(%rsp)
je 0x1ada
leaq 0x100(%rsp), %r15
movl 0x1c(%r15), %ebx
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x194e
movl 0x2c(%r12), %eax
movl %eax, 0x1c(%r15)
decl 0x24(%r15)
xorl %edi, %edi
movq %r15, %rsi
callq 0x12e3
testl %eax, %eax
js 0x1aeb
movb %r14b, 0x80(%rsp)
movb %bpl, 0x81(%rsp)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x88(%rsp)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x90(%rsp)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x98(%rsp)
movq $0x1, 0xa0(%rsp)
andl $0x0, 0xa8(%rsp)
pushq $0xb
popq %rax
cmpq $0x17, %rax
je 0x1a9c
andl $0x0, 0x80(%rsp,%rax,4)
incq %rax
jmp 0x1a79
leaq 0x26e9(%rip), %rdi      # 0x417c
callq 0x1060
pushq $-0x1
jmp 0x1ae8
pushq $0x17
popq %rax
cmpq $0x1a, %rax
je 0x1ab2
andl $0x0, 0x80(%rsp,%rax,4)
incq %rax
jmp 0x1a9f
pushq $0x10
popq %rcx
leaq 0x80(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl %ebx, %edi
callq 0x18d9
testl %eax, %eax
jns 0x1afa
pushq $-0x4
popq %rbx
leaq 0x270e(%rip), %rdi      # 0x41e6
jmp 0x1af5
leaq 0x26c2(%rip), %rdi      # 0x41a3
callq 0x1060
pushq $-0x2
popq %rbx
jmp 0x1afa
pushq $-0x3
popq %rbx
leaq 0x26c3(%rip), %rdi      # 0x41b8
callq 0x1060
movl %ebx, %eax
addq $0x500, %rsp            # imm = 0x500
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros_basico.c
// Function: liberar_inodo
int liberar_inodo (unsigned int inodo) {
	if(liberar_bloques_inodo(inodo,0) < 0) return -2;	//Llamar a la funcion auxiliar para liberar los bloques Error LBI
	struct inodo in;
	struct superbloque sb;
	
	if(bread(posSB,&sb) < 0) return -1; //Leer el superbloque Error BREAD
	in = leer_inodo(inodo);
	in.tipo = 'l'; //Marcar el inodo como tipo libre
	in.punterosDirectos[0] = sb.posPrimerInodoLibre; //Incluirlo en la lista de inodos libres
	sb.posPrimerInodoLibre = inodo; //Actualizar el superbloque
	sb.cantInodosLibres++; //Incrementar la cantidad de inodos libres
	if(bwrite(posSB,&sb) < 0) return -4; //Escribir el superbloque Error BWRITE
	if(escribir_inodo(in, inodo) < 0) return -5; //Escribir el inodo Error ESCRIBIR_INODO
	return inodo; //Devolver el num del inodo liberado	
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
movl %edi, %ebx
xorl %esi, %esi
callq 0x1ba4
testl %eax, %eax
js 0x1b8e
leaq 0x108(%rsp), %rsi
xorl %edi, %edi
callq 0x1319
testl %eax, %eax
js 0x1b92
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x194e
movb $0x6c, (%r14)
leaq 0x108(%rsp), %rsi
movl 0x1c(%rsi), %eax
movl %eax, 0x2c(%r14)
movl %ebx, 0x1c(%rsi)
incl 0x24(%rsi)
xorl %edi, %edi
callq 0x12e3
testl %eax, %eax
js 0x1b96
pushq $0x10
popq %rcx
leaq 0x88(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl %ebx, %edi
callq 0x18d9
testl %eax, %eax
pushq $-0x5
popq %rax
cmovnsl %ebx, %eax
jmp 0x1b99
pushq $-0x2
jmp 0x1b98
pushq $-0x1
jmp 0x1b98
pushq $-0x4
popq %rax
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros.c
// Function: mi_chmod_f
int mi_chmod_f (unsigned int inodo, unsigned char permisos) {
	struct inodo in;
	in = leer_inodo(inodo);
	if(permisos < 0 || permisos > 7) return -2; // Error PERMISOS_INV
	in.permisos = permisos;
	in.ctime = time(NULL);
	if(escribir_inodo(in, inodo) < 0) return -3; //Escribimos el inodo modificado Error ESCRIBIR_INODO
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl %esi, %ebp
movl %edi, %ebx
leaq 0x80(%rsp), %rdi
movl %ebx, %esi
callq 0x194e
cmpb $0x7, %bpl
jbe 0x2b52
pushq $-0x2
popq %rax
jmp 0x2b82
leaq 0x80(%rsp), %r14
movb %bpl, 0x1(%r14)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x18(%r14)
pushq $0x10
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %ebx, %edi
callq 0x18d9
sarl $0x1f, %eax
andl $-0x3, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros.c
// Function: mi_truncar_f
int mi_truncar_f (unsigned int inodo, unsigned int nbytes) {
	struct inodo in;
	in = leer_inodo(inodo);
	int bytesl;
	if((in.permisos & 2) != 2) return -2; //Error NO_PERMISOS_ESCRITURA
	if(nbytes == 0) bytesl = 0;
	else if(nbytes%tamBloque == 0) bytesl = nbytes/tamBloque;
	else bytesl = nbytes/tamBloque+1;
	if(liberar_bloques_inodo(inodo,bytesl) < 0) return -3; //Error LBI
	in = leer_inodo(inodo);
	in.mtime = time(NULL);
	in.ctime = time(NULL);
	in.tamBytesLogicos = nbytes;
	if(escribir_inodo(in, inodo) < 0) return -4; //Escribimos el inodo modificado Error ESCRIBIR_INODO
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %esi, %ebp
movl %edi, %ebx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x194e
testb $0x2, 0x1(%r14)
jne 0x2bc1
pushq $-0x2
jmp 0x2c4a
testl %ebp, %ebp
je 0x2bd9
movl %ebp, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %ebp, %esi
shrl $0xa, %esi
cmpl $0x1, %eax
sbbl $-0x1, %esi
jmp 0x2bdb
xorl %esi, %esi
movl %ebx, %edi
callq 0x1ba4
testl %eax, %eax
js 0x2c48
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x194e
pushq $0x10
popq %r15
leaq 0x80(%rsp), %r12
movq %r15, %rcx
movq %r12, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x10(%r12)
xorl %edi, %edi
callq 0x1120
movq %rax, 0x18(%r12)
movl %ebp, 0x24(%r12)
movq %r15, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %ebx, %edi
callq 0x18d9
sarl $0x1f, %eax
andl $-0x4, %eax
jmp 0x2c4b
pushq $-0x3
popq %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/ficheros.c
// Function: mi_stat_f
int mi_stat_f (unsigned int inodo, struct STAT *stat) {
	struct inodo in;
	in = leer_inodo(inodo);

	//Devolvemos la informacion
	stat->tipo = in.tipo;
	stat->permisos = in.permisos;
	stat->atime = in.atime;
	stat->mtime = in.mtime;
	stat->ctime = in.ctime;
	stat->cantLinks = in.cantLinks;
	stat->tamBytesLogicos = in.tamBytesLogicos;
	stat->cantBloquesOcupados = in.cantBloquesOcupados;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x194e
movzwl (%r14), %eax
movups 0x18(%r14), %xmm0
movl 0x28(%r14), %ecx
movups 0x8(%r14), %xmm1
movw %ax, (%rbx)
movups %xmm1, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movl %ecx, 0x28(%rbx)
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/directorios.c
// Function: extraer_camino
int extraer_camino (const char *camino, char *inicial, char *final) {
	int i = 1, f = 0;

	if (camino[0]!='/') return -1; //Error CAMINO_INV

	//Para obtener el directorio inicial
	while ((camino[i] != '/') && (camino[i] != '\0')){
		inicial[i-1] = camino[i];
		i++;
	}

	if (i == strlen(camino)) { //Se trata de un fichero
		final = "\0";
		return 1; // FICHERO
	}

	while (i < strlen(camino)) {
		final[f] = camino[i];
		i++; f++;
	}
	return 0; //DIRECTORIO
}

// Assembly:
cmpb $0x2f, (%rdi)
jne 0x2cd0
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x2cd4
cmpl $0x2f, %eax
je 0x2cd4
movb %al, -0x1(%rsi,%r15)
incq %r15
jmp 0x2cb8
pushq $-0x1
popq %rax
retq
movq %r14, %rdi
callq 0x1080
cmpq %r15, %rax
jne 0x2ce6
pushq $0x1
popq %rax
jmp 0x2d03
movq %r14, %rdi
callq 0x1080
cmpq %r15, %rax
jbe 0x2d01
movb (%r14,%r15), %al
movb %al, (%rbx)
incq %r15
incq %rbx
jmp 0x2ce6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/carlitosmarin[P]Sistema-Ficheros-SOII/./src/directorios.c
// Function: mi_creat
int mi_creat (const char *camino, unsigned char permisos) {
	unsigned int pid = 0, pi = 0, pe = 0;
	mi_waitSem();
	int BE = buscar_entrada(camino, &pid, &pi, &pe, 1, permisos);
	if(BE < 0) { //Tratamiento de errores
		switch(BE){
		case -1: printf("\"%s\" Camino no valido\n", camino); break;
		case -2: printf("No tienes permisos de lectura\n"); break;
		case -3: printf("Error en la lectura de la entrada \"%s\"\n", camino); break;
		case -4: printf("No existe la entrada \"%s\"\n", camino); break;
		case -5: printf("Error a la hora de reservar un inodo"); break;
		case -6: printf("No existe directorio intermedio a \"%s\"", camino); break;
		case -7: printf("Error a la hora de liberar un inodo"); break;
		case -8: printf("Error en la escritura de la entrada \"%s\"\n", camino); break;
		case -9: printf("Ya existe la entrada \"%s\"\n", camino); break;
		}
		puts("Falla MI_CREAT");
		mi_signalSem();
		return -1; //Error BE
	}
	mi_signalSem();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x14(%rsp), %r15
andl $0x0, (%r15)
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x134f
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %r9d
callq 0x2d09
testl %eax, %eax
jns 0x30da
addl $0x9, %eax
leaq 0x11db(%rip), %rcx      # 0x4238
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1403(%rip), %rdi      # 0x4470
jmp 0x30c1
leaq 0x1360(%rip), %rdi      # 0x43d6
jmp 0x307f
leaq 0x13a3(%rip), %rdi      # 0x4422
xorl %eax, %eax
callq 0x1090
jmp 0x30cb
leaq 0x136c(%rip), %rdi      # 0x43fb
jmp 0x30c1
leaq 0x1469(%rip), %rdi      # 0x4501
callq 0x1060
jmp 0x30cb
leaq 0x13a0(%rip), %rdi      # 0x4446
jmp 0x30c1
leaq 0x130c(%rip), %rdi      # 0x43bb
jmp 0x30c1
leaq 0x12db(%rip), %rdi      # 0x4393
jmp 0x30c1
leaq 0x12bb(%rip), %rdi      # 0x437c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1090
leaq 0x13b9(%rip), %rdi      # 0x448b
callq 0x1060
pushq $-0x1
popq %rbp
xorl %eax, %eax
callq 0x135b
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq