LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movl %edi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x15cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16a9
leaq -0x810(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movl -0x408(%rbp), %eax
movl %eax, -0x814(%rbp)
movl -0x814(%rbp), %eax
cmpl -0x404(%rbp), %eax
ja 0x1630
movl -0x814(%rbp), %edi
leaq -0x810(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x161d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16a9
jmp 0x161f
movl -0x814(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x814(%rbp)
jmp 0x15ec
movl $0x0, -0x814(%rbp)
movl -0x814(%rbp), %eax
cmpl -0x3fc(%rbp), %eax
ja 0x1686
movl -0x814(%rbp), %edi
movl $0x1, %esi
callq 0x16c0
cmpl $0x0, %eax
jge 0x1666
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x16a9
movl -0x3e8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3e8(%rbp)
movl -0x814(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x814(%rbp)
jmp 0x163a
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x16a2
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
leaq -0x40c(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x16f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17e5
movl -0x8(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x410(%rbp)
movl -0x8(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x414(%rbp)
movl -0x410(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
addl -0x40c(%rbp), %eax
movl %eax, -0x418(%rbp)
movl -0x410(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %edx, -0x410(%rbp)
movl -0x418(%rbp), %edi
leaq -0x820(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1759
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17e5
movb $-0x80, -0x821(%rbp)
movl -0x414(%rbp), %ecx
movzbl -0x821(%rbp), %eax
sarl %cl, %eax
movb %al, -0x821(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x179f
movzbl -0x821(%rbp), %edx
xorl $-0x1, %edx
movslq -0x410(%rbp), %rax
movzbl -0x820(%rbp,%rax), %ecx
andl %edx, %ecx
movb %cl, -0x820(%rbp,%rax)
jmp 0x17be
movzbl -0x821(%rbp), %edx
movslq -0x410(%rbp), %rax
movzbl -0x820(%rbp,%rax), %ecx
orl %edx, %ecx
movb %cl, -0x820(%rbp,%rax)
movl -0x418(%rbp), %edi
leaq -0x820(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x17de
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x17e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movl %edi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x182d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x193a
movl $0x1, -0x814(%rbp)
movl -0x400(%rbp), %eax
movl %eax, -0x818(%rbp)
movl -0x818(%rbp), %eax
cmpl -0x3fc(%rbp), %eax
ja 0x1933
movl $0x0, -0x81c(%rbp)
cmpl $0x8, -0x81c(%rbp)
jae 0x18fd
movl -0x81c(%rbp), %eax
movl %eax, %ecx
leaq -0x810(%rbp), %rax
shlq $0x7, %rcx
addq %rcx, %rax
movb $0x6c, (%rax)
movl -0x814(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x18c0
movl -0x814(%rbp), %ecx
movl -0x81c(%rbp), %eax
movl %eax, %edx
leaq -0x810(%rbp), %rax
shlq $0x7, %rdx
addq %rdx, %rax
movl %ecx, 0x2c(%rax)
movl -0x814(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x814(%rbp)
jmp 0x18e7
movl -0x81c(%rbp), %eax
movl %eax, %ecx
leaq -0x810(%rbp), %rax
shlq $0x7, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl $0x8, -0x81c(%rbp)
jmp 0x18e9
movl -0x81c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x81c(%rbp)
jmp 0x185f
movl -0x818(%rbp), %edi
leaq -0x810(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x191d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x193a
jmp 0x191f
movl -0x818(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x818(%rbp)
jmp 0x1843
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
xorl %edi, %edi
leaq -0x404(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x197a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a7f
leaq 0x46cd(%rip), %rdi      # 0x604e
movb $0x0, %al
callq 0x1090
movl -0x404(%rbp), %esi
leaq 0x46e4(%rip), %rdi      # 0x6079
movb $0x0, %al
callq 0x1090
movl -0x400(%rbp), %esi
leaq 0x46e6(%rip), %rdi      # 0x608f
movb $0x0, %al
callq 0x1090
movl -0x3fc(%rbp), %esi
leaq 0x46e8(%rip), %rdi      # 0x60a5
movb $0x0, %al
callq 0x1090
movl -0x3f8(%rbp), %esi
leaq 0x46ea(%rip), %rdi      # 0x60bb
movb $0x0, %al
callq 0x1090
movl -0x3f4(%rbp), %esi
leaq 0x46ec(%rip), %rdi      # 0x60d1
movb $0x0, %al
callq 0x1090
movl -0x3f0(%rbp), %esi
leaq 0x46f1(%rip), %rdi      # 0x60ea
movb $0x0, %al
callq 0x1090
movl -0x3ec(%rbp), %esi
leaq 0x46f6(%rip), %rdi      # 0x6103
movb $0x0, %al
callq 0x1090
movl -0x3e8(%rbp), %esi
leaq 0x46fc(%rip), %rdi      # 0x611d
movb $0x0, %al
callq 0x1090
movl -0x3e4(%rbp), %esi
leaq 0x4700(%rip), %rdi      # 0x6135
movb $0x0, %al
callq 0x1090
movl -0x3e0(%rbp), %esi
leaq 0x4709(%rip), %rdi      # 0x6152
movb $0x0, %al
callq 0x1090
movl -0x3dc(%rbp), %esi
leaq 0x4711(%rip), %rdi      # 0x616e
movb $0x0, %al
callq 0x1090
movl -0x3d8(%rbp), %esi
leaq 0x471b(%rip), %rdi      # 0x618c
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movl %edi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1aba
movb $-0x1, -0x1(%rbp)
jmp 0x1b7a
movl -0x8(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x40c(%rbp)
movl -0x8(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x410(%rbp)
movl -0x40c(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
addl -0x408(%rbp), %eax
movl %eax, -0x414(%rbp)
movl -0x40c(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %edx, -0x40c(%rbp)
movl -0x414(%rbp), %edi
leaq -0x820(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1b1d
movb $-0x2, -0x1(%rbp)
jmp 0x1b7a
movb $-0x80, -0x821(%rbp)
movl -0x410(%rbp), %ecx
movzbl -0x821(%rbp), %eax
sarl %cl, %eax
movb %al, -0x821(%rbp)
movslq -0x40c(%rbp), %rax
movzbl -0x820(%rbp,%rax), %ecx
movzbl -0x821(%rbp), %eax
andl %ecx, %eax
movb %al, -0x821(%rbp)
movl $0x7, %ecx
subl -0x410(%rbp), %ecx
movzbl -0x821(%rbp), %eax
sarl %cl, %eax
movb %al, -0x821(%rbp)
movb -0x821(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movl %edi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1dea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e33
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0x16c0
cmpl $0x0, %eax
jge 0x1e02
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1e33
movl -0x3e8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3e8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x1e2d
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x1e33
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
leaq 0x10(%rbp), %rax
movq %rax, -0x820(%rbp)
movl %edi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x408(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1e78
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f06
movl -0x8(%rbp), %eax
shll $0x7, %eax
shrl $0xa, %eax
addl -0x400(%rbp), %eax
movl %eax, -0x40c(%rbp)
movl -0x40c(%rbp), %edi
leaq -0x810(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x1ead
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f06
movq -0x820(%rbp), %rsi
movl -0x8(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x814(%rbp)
movslq -0x814(%rbp), %rax
leaq -0x810(%rbp), %rdi
shlq $0x7, %rax
addq %rax, %rdi
movl $0x80, %edx
callq 0x1120
movl -0x40c(%rbp), %edi
leaq -0x810(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x1eff
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1f06
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movq %rdi, -0x820(%rbp)
movq %rdi, -0x818(%rbp)
movl %esi, -0x4(%rbp)
xorl %edi, %edi
leaq -0x404(%rbp), %rsi
callq 0x1380
movl -0x4(%rbp), %eax
shll $0x7, %eax
shrl $0xa, %eax
addl -0x3fc(%rbp), %eax
movl %eax, -0x408(%rbp)
movl -0x408(%rbp), %edi
leaq -0x810(%rbp), %rsi
callq 0x1380
movq -0x820(%rbp), %rdi
movl -0x4(%rbp), %eax
andl $0x7, %eax
movl %eax, %eax
leaq -0x810(%rbp), %rsi
shlq $0x7, %rax
addq %rax, %rsi
movl $0x80, %edx
callq 0x1120
movq -0x818(%rbp), %rax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x590, %rsp            # imm = 0x590
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0x2310
cmpl $0x0, %eax
jge 0x2209
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x22fb
xorl %edi, %edi
leaq -0x488(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
jge 0x2228
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22fb
movl -0x8(%rbp), %esi
leaq -0x508(%rbp), %rdi
callq 0x1f20
leaq -0x88(%rbp), %rdi
leaq -0x508(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
movb $0x6c, -0x88(%rbp)
movl -0x46c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x46c(%rbp)
movl -0x464(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x464(%rbp)
xorl %edi, %edi
leaq -0x488(%rbp), %rsi
callq 0x1320
cmpl $0x0, %eax
jge 0x2293
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x22fb
movl -0x8(%rbp), %edi
movups -0x18(%rbp), %xmm0
movq %rsp, %rax
movq %rax, -0x510(%rbp)
movups %xmm0, 0x70(%rax)
movups -0x28(%rbp), %xmm0
movups %xmm0, 0x60(%rax)
movups -0x38(%rbp), %xmm0
movups %xmm0, 0x50(%rax)
movups -0x48(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x88(%rbp), %xmm0
movups -0x78(%rbp), %xmm1
movups -0x68(%rbp), %xmm2
movups -0x58(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1e40
cmpl $0x0, %eax
jge 0x22f5
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x22fb
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x590, %rsp            # imm = 0x590
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl -0x8(%rbp), %esi
leaq -0x110(%rbp), %rdi
callq 0x1f20
leaq -0x90(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jl 0x420d
movzbl -0x9(%rbp), %eax
cmpl $0x7, %eax
jle 0x4216
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4295
movb -0x9(%rbp), %al
movb %al, -0x8f(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1130
movq %rax, -0x78(%rbp)
movl -0x8(%rbp), %edi
movups -0x20(%rbp), %xmm0
movq %rsp, %rax
movq %rax, -0x118(%rbp)
movups %xmm0, 0x70(%rax)
movups -0x30(%rbp), %xmm0
movups %xmm0, 0x60(%rax)
movups -0x40(%rbp), %xmm0
movups %xmm0, 0x50(%rax)
movups -0x50(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x90(%rbp), %xmm0
movups -0x80(%rbp), %xmm1
movups -0x70(%rbp), %xmm2
movups -0x60(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1e40
cmpl $0x0, %eax
jge 0x428e
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x4295
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %esi
leaq -0x110(%rbp), %rdi
callq 0x1f20
leaq -0x90(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
movzbl -0x8f(%rbp), %eax
andl $0x2, %eax
cmpl $0x2, %eax
je 0x4303
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4410
cmpl $0x0, -0xc(%rbp)
jne 0x4315
movl $0x0, -0x114(%rbp)
jmp 0x4341
movl -0xc(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl $0x0, %eax
jne 0x4330
movl -0xc(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x114(%rbp)
jmp 0x433f
movl -0xc(%rbp), %eax
shrl $0xa, %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x4341
movl -0x8(%rbp), %edi
movl -0x114(%rbp), %esi
callq 0x2310
cmpl $0x0, %eax
jge 0x4360
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x4410
movl -0x8(%rbp), %esi
leaq -0x198(%rbp), %rdi
callq 0x1f20
leaq -0x90(%rbp), %rdi
leaq -0x198(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
xorl %eax, %eax
movl %eax, %edi
callq 0x1130
movq %rax, -0x80(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1130
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x8(%rbp), %edi
movups -0x20(%rbp), %xmm0
movq %rsp, %rax
movq %rax, -0x1a0(%rbp)
movups %xmm0, 0x70(%rax)
movups -0x30(%rbp), %xmm0
movups %xmm0, 0x60(%rax)
movups -0x40(%rbp), %xmm0
movups %xmm0, 0x50(%rax)
movups -0x50(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x90(%rbp), %xmm0
movups -0x80(%rbp), %xmm1
movups -0x70(%rbp), %xmm2
movups -0x60(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1e40
cmpl $0x0, %eax
jge 0x4409
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x4410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %esi
leaq -0x110(%rbp), %rdi
callq 0x1f20
leaq -0x90(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
movb -0x90(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x8f(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x88(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x70(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x6c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x68(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x450a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45e7
jmp 0x450c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x29(%rbp)
je 0x4537
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4540
jmp 0x4566
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x450c
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x4597
leaq 0x1e16(%rip), %rax      # 0x63a0
movq %rax, -0x20(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0x45e7
jmp 0x4599
movslq -0x24(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x45e0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4599
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, %al
callq 0x13e0
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movl $0x1, %r8d
movzbl -0x11(%rbp), %r9d
callq 0x45f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x4ccc
movl -0x24(%rbp), %eax
addl $0x9, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x8, %eax
ja 0x4cb0
movq -0x30(%rbp), %rax
leaq 0x1661(%rip), %rcx      # 0x625c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0x1795(%rip), %rdi      # 0x63a4
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
leaq 0x1799(%rip), %rdi      # 0x63bb
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
movq -0x10(%rbp), %rsi
leaq 0x17a1(%rip), %rdi      # 0x63da
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
movq -0x10(%rbp), %rsi
leaq 0x17b5(%rip), %rdi      # 0x6402
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
leaq 0x17c0(%rip), %rdi      # 0x641d
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
movq -0x10(%rbp), %rsi
leaq 0x17d1(%rip), %rdi      # 0x6442
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
leaq 0x17e8(%rip), %rdi      # 0x6469
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
movq -0x10(%rbp), %rsi
leaq 0x17f8(%rip), %rdi      # 0x648d
movb $0x0, %al
callq 0x1090
jmp 0x4cb0
movq -0x10(%rbp), %rsi
leaq 0x180e(%rip), %rdi      # 0x64b7
movb $0x0, %al
callq 0x1090
leaq 0x181b(%rip), %rdi      # 0x64d2
callq 0x1060
movb $0x0, %al
callq 0x1400
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4cda
movb $0x0, %al
callq 0x1400
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/directorios.c
// Function: mi_chmod
int mi_chmod (const char *camino, unsigned char permisos) {
	int pid = 0, pi = 0, pe = 0;
	int BE = buscar_entrada(camino, &pid, &pi, &pe, 0, 0);

	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;
		}
		return -1; //Error BE
	} else {
		if(mi_chmod_f(pi,permisos) < 0) return -2; //Error CHMOD
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x45f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x58bd
movl -0x24(%rbp), %eax
addl $0x9, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x8, %eax
ja 0x58b4
movq -0x30(%rbp), %rax
leaq 0xb11(%rip), %rcx       # 0x6310
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0xb91(%rip), %rdi       # 0x63a4
movb $0x0, %al
callq 0x1090
jmp 0x58b4
leaq 0xb95(%rip), %rdi       # 0x63bb
movb $0x0, %al
callq 0x1090
jmp 0x58b4
movq -0x10(%rbp), %rsi
leaq 0xb9d(%rip), %rdi       # 0x63da
movb $0x0, %al
callq 0x1090
jmp 0x58b4
movq -0x10(%rbp), %rsi
leaq 0xbb1(%rip), %rdi       # 0x6402
movb $0x0, %al
callq 0x1090
jmp 0x58b4
leaq 0xbbc(%rip), %rdi       # 0x641d
movb $0x0, %al
callq 0x1090
jmp 0x58b4
movq -0x10(%rbp), %rsi
leaq 0xbcd(%rip), %rdi       # 0x6442
movb $0x0, %al
callq 0x1090
jmp 0x58b4
leaq 0xbe4(%rip), %rdi       # 0x6469
movb $0x0, %al
callq 0x1090
jmp 0x58b4
movq -0x10(%rbp), %rsi
leaq 0xbf4(%rip), %rdi       # 0x648d
movb $0x0, %al
callq 0x1090
jmp 0x58b4
movq -0x10(%rbp), %rsi
leaq 0xc0a(%rip), %rdi       # 0x64b7
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x58e0
movl -0x1c(%rbp), %edi
movzbl -0x11(%rbp), %esi
callq 0x41c0
cmpl $0x0, %eax
jge 0x58d7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x58e0
jmp 0x58d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/directorios.c
// Function: mi_stat
int mi_stat (const char *camino, struct STAT *p_stat) {
	int pid = 0, pi = 0, pe = 0;
	int BE = buscar_entrada(camino, &pid, &pi, &pe, 0, 0);

	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;
		}
		return -1; //Error BE
	} else {
		if(mi_stat_f(pi,p_stat) < 0) return -2; //Error STAT
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x45f0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x5a1b
movl -0x28(%rbp), %eax
addl $0x9, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x8, %eax
ja 0x5a12
movq -0x30(%rbp), %rax
leaq 0x9d7(%rip), %rcx       # 0x6334
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0xa33(%rip), %rdi       # 0x63a4
movb $0x0, %al
callq 0x1090
jmp 0x5a12
leaq 0xa37(%rip), %rdi       # 0x63bb
movb $0x0, %al
callq 0x1090
jmp 0x5a12
movq -0x10(%rbp), %rsi
leaq 0xa3f(%rip), %rdi       # 0x63da
movb $0x0, %al
callq 0x1090
jmp 0x5a12
movq -0x10(%rbp), %rsi
leaq 0xa53(%rip), %rdi       # 0x6402
movb $0x0, %al
callq 0x1090
jmp 0x5a12
leaq 0xa5e(%rip), %rdi       # 0x641d
movb $0x0, %al
callq 0x1090
jmp 0x5a12
movq -0x10(%rbp), %rsi
leaq 0xa6f(%rip), %rdi       # 0x6442
movb $0x0, %al
callq 0x1090
jmp 0x5a12
leaq 0xa86(%rip), %rdi       # 0x6469
movb $0x0, %al
callq 0x1090
jmp 0x5a12
movq -0x10(%rbp), %rsi
leaq 0xa96(%rip), %rdi       # 0x648d
movb $0x0, %al
callq 0x1090
jmp 0x5a12
movq -0x10(%rbp), %rsi
leaq 0xaac(%rip), %rdi       # 0x64b7
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5a3e
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4420
cmpl $0x0, %eax
jge 0x5a35
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x5a3e
jmp 0x5a37
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/directorios.c
// Function: mi_read
int mi_read (const char *camino, void *buf, unsigned int offset, unsigned int nbytes) {
	int pid = 0, pi = 0, pe = 0, bytesLeidos;
	int BE = buscar_entrada(camino, &pid, &pi, &pe, 0, 0);

	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_READ");
		return -1; //Error READ
	} else {
		if((bytesLeidos = mi_read_f(pi,buf,offset,nbytes)) < 0) return -2; //Error READ
	}
	return bytesLeidos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x45f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x5b8d
movl -0x34(%rbp), %eax
addl $0x9, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x8, %eax
ja 0x5b78
movq -0x40(%rbp), %rax
leaq 0x895(%rip), %rcx       # 0x6358
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0x8cd(%rip), %rdi       # 0x63a4
movb $0x0, %al
callq 0x1090
jmp 0x5b78
leaq 0x8d1(%rip), %rdi       # 0x63bb
movb $0x0, %al
callq 0x1090
jmp 0x5b78
movq -0x10(%rbp), %rsi
leaq 0x8d9(%rip), %rdi       # 0x63da
movb $0x0, %al
callq 0x1090
jmp 0x5b78
movq -0x10(%rbp), %rsi
leaq 0x8ed(%rip), %rdi       # 0x6402
movb $0x0, %al
callq 0x1090
jmp 0x5b78
leaq 0x8f8(%rip), %rdi       # 0x641d
movb $0x0, %al
callq 0x1090
jmp 0x5b78
movq -0x10(%rbp), %rsi
leaq 0x909(%rip), %rdi       # 0x6442
movb $0x0, %al
callq 0x1090
jmp 0x5b78
leaq 0x920(%rip), %rdi       # 0x6469
movb $0x0, %al
callq 0x1090
jmp 0x5b78
movq -0x10(%rbp), %rsi
leaq 0x930(%rip), %rdi       # 0x648d
movb $0x0, %al
callq 0x1090
jmp 0x5b78
movq -0x10(%rbp), %rsi
leaq 0x946(%rip), %rdi       # 0x64b7
movb $0x0, %al
callq 0x1090
leaq 0x994(%rip), %rdi       # 0x6513
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bb8
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x3d00
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jge 0x5bb0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x5bb8
jmp 0x5bb2
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/./src/semaforo_mutex_posix.c
// Function: initSem
sem_t *initSem() {
	/* name debe ser un nombre de caracteres ascii que comienze con "/", p.e. "/mimutex" */
	sem_t *sem;

	sem = sem_open(SEM_NAME, O_CREAT, S_IRWXU, SEM_INIT_VALUE);
	if (sem == SEM_FAILED) {
		return NULL;
	}
	return sem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7a1(%rip), %rdi       # 0x6550
movl $0x40, %esi
movl $0x1c0, %edx            # imm = 0x1C0
movl $0x1, %ecx
movb $0x0, %al
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5dda
movq $0x0, -0x8(%rbp)
jmp 0x5de2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/mi_rm.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 3) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	bmount(argv[1]);

	struct STAT stat;
	if(mi_stat(argv[2],&stat) < 0){
		bumount();
		return 0;
	}

	if(stat.tipo == 'd' && stat.tamBytesLogicos != 0){
		printf("El directorio %s no está vacio, no puede ser borrado\n", argv[2]);
		bumount();
		return 0;
	}
	if(mi_unlink(argv[2]) == 0){
		puts("Se ha borrado correctamente.");
	} else ("Error: No se ha podido eliminar el fichero con mi_rm\n");

	bumount();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x5e86
leaq 0x6e6(%rip), %rdi       # 0x6559
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f1e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1280
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x58f0
cmpl $0x0, %eax
jge 0x5eb9
movb $0x0, %al
callq 0x12e0
movl $0x0, -0x4(%rbp)
jmp 0x5f1e
movzbl -0x40(%rbp), %eax
cmpl $0x64, %eax
jne 0x5eee
cmpl $0x0, -0x1c(%rbp)
je 0x5eee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6a5(%rip), %rdi       # 0x657c
movb $0x0, %al
callq 0x1090
movb $0x0, %al
callq 0x12e0
movl $0x0, -0x4(%rbp)
jmp 0x5f1e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5480
cmpl $0x0, %eax
jne 0x5f0e
leaq 0x6ac(%rip), %rdi       # 0x65b3
callq 0x1060
jmp 0x5f10
jmp 0x5f10
movb $0x0, %al
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/common.c
// Function: get_width
int get_width(char *buf)
{
	int size = 0;
	
	if(!strcmp(buf, "void")){
		size = 0;
	}else if(!strcmp(buf, "i1")){
		size = 1;
	}else if(!strcmp(buf, "i8")){
		size = 8;
	}else if(!strcmp(buf, "i16")){
		size = 16;
	}else if(!strcmp(buf, "i32")){
		size = 32;
	}else if(buf[strlen(buf)-1] == '*'){
		// �|�C���^�錾(�|�C���^�͍Ō���'*'���t��)
		// �|�C���^��i8*, i16*, i32*, %�\���̖�*, ARRAY�錾*, ���z��
		size = 32;
	}else{
		/*
		 * ToDo:
		 * �������Ə������邱�ƁB���܂̂Ƃ����b�肾���B
		 */
		size = 32;
		printf("[WRANING] get_width(): %s\n", buf);
	}

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11d46(%rip), %rsi     # 0x13004
callq 0x10d0
cmpl $0x0, %eax
jne 0x12d4
movl $0x0, -0xc(%rbp)
jmp 0x13a3
movq -0x8(%rbp), %rdi
leaq 0x11d2a(%rip), %rsi     # 0x13009
callq 0x10d0
cmpl $0x0, %eax
jne 0x12f5
movl $0x1, -0xc(%rbp)
jmp 0x13a1
movq -0x8(%rbp), %rdi
leaq 0x11d0c(%rip), %rsi     # 0x1300c
callq 0x10d0
cmpl $0x0, %eax
jne 0x1316
movl $0x8, -0xc(%rbp)
jmp 0x139f
movq -0x8(%rbp), %rdi
leaq 0x11cee(%rip), %rsi     # 0x1300f
callq 0x10d0
cmpl $0x0, %eax
jne 0x1334
movl $0x10, -0xc(%rbp)
jmp 0x139d
movq -0x8(%rbp), %rdi
leaq 0x12f5a(%rip), %rsi     # 0x14299
callq 0x10d0
cmpl $0x0, %eax
jne 0x1352
movl $0x20, -0xc(%rbp)
jmp 0x139b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x1380
movl $0x20, -0xc(%rbp)
jmp 0x1399
movl $0x20, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x11c81(%rip), %rdi     # 0x13013
movb $0x0, %al
callq 0x1090
jmp 0x139b
jmp 0x139d
jmp 0x139f
jmp 0x13a1
jmp 0x13a3
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/common.c
// Function: convname
char *convname(char *buf)
{
	int i;
	if((buf[0] == '%') || (buf[0] == '@')){
		for(i=0;i<strlen(buf)-1;i++){
			buf[i] = buf[i+1];
		}
		buf[strlen(buf)-1] = 0;
	}
	
	for(i=0;i<strlen(buf);i++){
		if(buf[i] == '.') buf[i] = '_';
	}

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x1424
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x1492
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1472
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x142b
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x14e0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x14d3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0x14d5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1499
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/parser.c
// Function: insert_parser_tree
int insert_parser_tree(char *str)
{
    // パーサーツリーの新規登録
    if(parser_tree_top == NULL){
        parser_tree_top     = (PARSER_TREE *)malloc(sizeof(PARSER_TREE));
        parser_tree_current = parser_tree_top;
    }else{
        parser_tree_current->next_ptr   = (PARSER_TREE *)malloc(sizeof(PARSER_TREE));
        parser_tree_prev                = parser_tree_current;
        parser_tree_current             = parser_tree_current->next_ptr;
        parser_tree_current->prev_ptr   = parser_tree_prev;
        parser_tree_current->next_ptr   = NULL;
    }

    // パーサーツリーに文字列の登録
	parser_tree_current->str = charalloc(str);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x16b8c(%rip)     # 0x180f0
jne 0x1587
movl $0x6c58, %edi           # imm = 0x6C58
callq 0x1100
movq %rax, 0x16b79(%rip)     # 0x180f0
movq 0x16b72(%rip), %rax     # 0x180f0
movq %rax, 0x16b73(%rip)     # 0x180f8
jmp 0x15df
movl $0x6c58, %edi           # imm = 0x6C58
callq 0x1100
movq %rax, %rcx
movq 0x16b5d(%rip), %rax     # 0x180f8
movq %rcx, 0x8(%rax)
movq 0x16b52(%rip), %rax     # 0x180f8
movq %rax, 0x16b53(%rip)     # 0x18100
movq 0x16b44(%rip), %rax     # 0x180f8
movq 0x8(%rax), %rax
movq %rax, 0x16b39(%rip)     # 0x180f8
movq 0x16b3a(%rip), %rcx     # 0x18100
movq 0x16b2b(%rip), %rax     # 0x180f8
movq %rcx, (%rax)
movq 0x16b21(%rip), %rax     # 0x180f8
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x13b0
movq %rax, %rcx
movq 0x16b06(%rip), %rax     # 0x180f8
movq %rcx, 0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/parser.c
// Function: create_proc_source
int create_proc_source()
{
//    PARSER_TREE *now_parser_tree;
//    PARSER_TREE *parser_tree_process;
//    unsigned int now_level;
    char *token;
    char *line;
    int func_num = 0;
	char *filename;
	FILE *fp;
	int size;
	char *const_header = "#include \"__extern.h\"\n\n\0";

    printf(" -> Create Process Source\n");
	
	token = calloc(STR_MAX, 1);
	line = calloc(STR_MAX, 1);

	filename = (char *)malloc(128);
	memset(filename, 0, 128);

    parser_tree_current = parser_tree_top;
    while(parser_tree_current != NULL){
        if(parser_tree_current->flag == PARSER_FLAG_PROCESS){
			sprintf(filename, "__%03d.c", func_num);
			func_num++;
			fp = fopen(filename, "wb+");
			/*
			 * ToDo: fopenのエラー処理が必要
			 */
			size = strlen(parser_tree_current->line.body);
			fwrite(const_header, 1, strlen(const_header), fp);
			fwrite(parser_tree_current->line.body, 1, size, fp);
			fclose(fp);
        }
        parser_tree_current = parser_tree_current->next_ptr;
    }

	free(token);
	free(line);

	free(filename);

    return func_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x14(%rbp)
leaq 0x119e8(%rip), %rax     # 0x1302e
movq %rax, -0x38(%rbp)
leaq 0x11a24(%rip), %rdi     # 0x13075
movb $0x0, %al
callq 0x1090
movl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
callq 0x10c0
movq %rax, -0x8(%rbp)
movl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
callq 0x10c0
movq %rax, -0x10(%rbp)
movl $0x80, %edi
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10a0
movq 0x16a4d(%rip), %rax     # 0x180f0
movq %rax, 0x16a4e(%rip)     # 0x180f8
cmpq $0x0, 0x16a46(%rip)     # 0x180f8
je 0x1777
movq 0x16a39(%rip), %rax     # 0x180f8
cmpl $0x19, 0x10(%rax)
jne 0x1760
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x139bb(%rip), %rsi     # 0x15092
movb $0x0, %al
callq 0x1160
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1199e(%rip), %rsi     # 0x13090
callq 0x1120
movq %rax, -0x28(%rbp)
movq 0x169f6(%rip), %rax     # 0x180f8
movq 0x6c50(%rax), %rdi
callq 0x1070
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1070
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1180
movq 0x169ba(%rip), %rax     # 0x180f8
movq 0x6c50(%rax), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1180
movq -0x28(%rbp), %rdi
callq 0x1060
movq 0x16991(%rip), %rax     # 0x180f8
movq 0x8(%rax), %rax
movq %rax, 0x16986(%rip)     # 0x180f8
jmp 0x16aa
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)