int fat32_open_file(uint8_t* filename, uint8_t* buff)
{
	if (!hd_exists() && !filename)
		return 1; 
	hd_read(start_of_root, FAT32_FILES_PER_DIRECTORY * sizeof(struct DirectoryEntry), (uint8_t*)&drce[0]);
 
	for (int i = 0; i < FAT32_FILES_PER_DIRECTORY; ++i) {
		if (drce[i].file_name[0] == FAT32_NO_FILES) 
			break;
		uint8_t* fatbuff = 0;
		uint8_t fil[12];
		fat2human(drce[i].file_name, fil);
		trimName(fil, 11);
		if (strcmp((char*)fil, (char*)filename) == 0) {
			uint8_t fcluster = ((uint32_t)drce[i].cluster_number_hi) << 16 | ((uint32_t)drce[i].cluster_number_lo);   
			int32_t ncluster = fcluster;
			int32_t file_size = drce[i].file_size;
 
			kputs("\nFile content: \n");
 
			/* 1 sector file (less than 512 bytes) */
			if (file_size < 512) {
				hd_read(fcluster, 512, buff);
				buff[file_size] = '\0';
				//kputs("%s", (char*)buff);
			}
 
			while (file_size > 0) {
				uint32_t fsect = start_of_data + bpb.sectors_per_cluster * (ncluster - 2);
				uint32_t sector_offset = 0;
				for (; file_size > 0; file_size -= 512) {
					hd_read(fsect + sector_offset, 512, buff);
					buff[file_size > 512 ? 512 : file_size] = '\0';
					//kputs("%s", (char*)buff);
					if (++sector_offset > bpb.sectors_per_cluster) 
						break;
				}
				uint32_t fsectcurrentcl = ncluster / (512 / sizeof(uint32_t));
 
				hd_read(fat_start + fsectcurrentcl, 512, fatbuff);
				uint32_t foffsectcurrentcl = ncluster % (512 / sizeof (uint32_t));
				ncluster = ((uint32_t*)&fatbuff)[foffsectcurrentcl] & 0x0FFFFFFF;
			}
			return 0;
		}
	}
	kputs("\nFile %s not found\n", filename);
	return 1;
}

uint8_t fileb[1024];
fat32_open_file(buff, fileb);
 

if (variableacomprobar & indexdelbit) {
    /* etc... */
}
 

|15...|7|6|5|4|3|2|1|0|
       | |
       1 0
     Ó
       0 1

/* Reservamos 16 elementos de string */
char* file_names_in_dir[16];
for (int i = 0; i < FAT32_FILES_PER_DIRECTORY; ++i) {
        ...
	if (drce[i].file_name[0] == 0x00)
		break;
	file_names_in_dir[i] = drce[i].file_name;
	++files_in_directory;
}
...
printf("%s", file_names_in_dir[0]);
...
 

kputs("r8: %x    r9: %x    r10: %x", r->r8, r->r9, r->r10);

r8: b8000└

int kputs(const char *fmt, ...) {
	/* Hacer nada si la cadena esta vacia. */
	if (!fmt)
		return 0;
	char buffer[1024] = {0};
	va_list args;
 
	size_t cout;
	unsigned int* charc;
	va_start(args, fmt);
 
	for (cout = 0; cout < strlen(fmt); ++cout) {
		switch (fmt[cout]) {
			case '%':
				switch (fmt[cout + 1]) {
					case 'c':
						charc = va_arg(args, unsigned int);
						putch(charc);
						++cout;
						break;
					case 's':
						charc = (int*) (va_arg(args, unsigned int));
						strcpy(buffer, (const char*) charc);
						print_string(buffer);
						++cout;
						break;
					case 'i':
						charc = va_arg(args, int);
						itoa(charc, buffer, 10);
						print_string(buffer);
						++cout;
						break;
					case 'X':
					case 'x':
						charc = va_arg(args, int);
						itoa((unsigned)charc, buffer, 16);
						print_string(buffer);
						++cout;
					case '%':
						putch("%");
						++cout;
 
					default:
						va_end(args);
						return 1;
				}
				break;
				default:
					putch(fmt[cout]);
					break;
		}
	}		
	va_end(args);
	return cout;
}
 

void k_readkb(char* buf, int n);

struct foo
{
    int bar = 3;
    int sumar(int x, int y);
};
 
int sumar(int x, int y)
{
    x += y;
}
 
int main()
{
    struct foo asd;
    int spam = asd.bar;
    asd.sumar(5, 5);
    return 0;
}
 

isr80:
    cli
    push byte 0
    push byte 80
    cmp eax, 3
    je .read_srv
    cmp eax, 4
    je .write_srv
    jmp .end
    .read_srv:
    mov ecx, strinputbuff
    mov eax, ebx
    call k_readkb
    xor eax, eax
    .write_srv:
    mov ecx, testmsg
    push ecx
    call kputs
    pop ecx
    jmp isr_common_stub
    .end: