typedef struct {
   float coord[3];
} vec3;
 
...
 
vec3 vertices[4] = {
    {-size, -size, 0.0f},
    { size, -size, 0.0f},
    {-size,  size, 0.0f},
    { size,  size, 0.0f}
};

../src/model.c: In function ‘load_quad’:
../src/model.c:8:9: warning: missing braces around initializer [-Wmissing-braces]
         {-size, -size, 0.0f},
         ^
../src/model.c:8:9: note: (near initialization for ‘vertices[0]’)
../src/model.c:9:9: warning: missing braces around initializer [-Wmissing-braces]
         { size, -size, 0.0f},
         ^
../src/model.c:9:9: note: (near initialization for ‘vertices[1]’)
../src/model.c:10:9: warning: missing braces around initializer [-Wmissing-braces]
         {-size,  size, 0.0f},
         ^
../src/model.c:10:9: note: (near initialization for ‘vertices[2]’)
../src/model.c:11:9: warning: missing braces around initializer [-Wmissing-braces]
         { size,  size, 0.0f}
         ^
../src/model.c:11:9: note: (near initialization for ‘vertices[3]’)
../src/model.c:7:24: warning: missing braces around initializer [-Wmissing-braces]
     vec3 vertices[4] = {
                        ^
../src/model.c:7:24: note: (near initialization for ‘vertices’)

BITS 16
 
start:
	xor ax, ax                 ; Set data segment to where we're loaded
	mov ds, ax
 
	mov ax, text_string
	add ax, 7C00h
	mov si, ax                 ; Put string position into SI
	call print_string          ; Call our string-printing routine
 
	jmp $                      ; Jump here - infinite loop!
 
 
text_string: db 'This is my cool new OS!', 0
 
 
print_string:                      ; Routine: output string in SI to screen
	mov ah, 0Eh                ; int 10h 'print char' function
 
.repeat:
	lodsb                      ; Get character from string
	cmp al, 0
	je .done                   ; If char is zero, end of string
	int 10h                    ; Otherwise, print it
	jmp .repeat
 
.done:
	ret
 
 
	times 510-($-$$) db 0      ; Pad remainder of boot sector with 0s
	dw 0xAA55

BITS 16
 
start:
	xor ax, ax                 ; Lo ponemos como 0
	mov ds, ax
 
	mov ax, text_string        ; Calculo manualmente la dirección de la caedna
	add ax, 7C00h
	mov si, ax                 ; La guardo en SI
 
        ...

BITS 16
 
start:
	mov ax 0x07C0          ; Lo ponemos como 0
	mov ds, ax
 
	mov ax, text_string    ; El cálculo debería ser DS * 0x10 + SI, lo que es lo mismo que 
                               ; 0x07C0 * 0x10 + SI, lo que es lo mismo que 0x7C00 + SI, que
                               ; a su vez es lo mismo que el cálculo manual antes expuesto
	mov si, ax             ; La guardo en SI
 
        ...

mov ah, 0x00
SAHF
CLC
CLD
CLTS
mov ax, 0x07C0
mov ds, ax

xor ax, ax            ; Algo más tiene que hacer XOR, porque aun reemplazando el valor de ax, sin XOR no funciona
mov ax, 0x07C0        ; Aquí reemplazamos todo ax
mov ds, ax

          #include<stdio.h>
 
 
 
 
                 int
                main(
               ){float
              rad=0.0f;
             float peri;
            float   areac
           =.0f;     const
          float       pi_2=
         1.5707f;char*areas=
        "Area";fprintf(stdout
       ,"Radio: ");scanf("%f",
      &rad);              peri=
     4.00f                 *pi_2
    *rad;                   areac
   =2.0f                     *pi_2
  *rad*                       *&rad
;fprintf                     (stdout,
 
 
 
 
"Perimeter: %f\n",peri);fprintf(stdo\
ut,"%s: %f",areas, areac); return 0;}

#include <stdlib.h>
#include <stdio.h>
 
// Para generalizar, uso un tipo de datos predefinido, así puedo
// cambiar entre int y el tipo de datos que quiera
typedef int tipo;
 
typedef struct ElementoLista{
	tipo dato;
	struct ElementoLista *siguiente;
} Elemento;
 
// En la estructura de una pila, solo necesitamos la referencia al
// último elemento agregado
typedef struct {
	Elemento *ultimo;
	unsigned int num_elementos;
} Pila;
 
// Pero en la estructura de una cola, también necesitaremos la
// referencia del primer elemento
typedef struct {
	Elemento *primero;
	Elemento *ultimo;
	unsigned int num_elementos;
} Cola;
 
// Si alguna de estas dos funciones retorna 0, significa que
// ha ocurrido un error, de lo contrario, retornará un valor
// diferente de 0
int agregar_a_pila(Pila *pila, tipo dato);
int agregar_a_cola(Cola *cola, tipo dato);
 
// Destruye el último elemento y retorna los datos almacenados en el
tipo quitar_a_pila(Pila *pila);
tipo quitar_a_cola(Cola *cola);
 
// Para demostrar el uso de 'quitar_a_pila' y 'quitar_a_cola'
// estas funciones destruyen la pila y la cola respectivamente
// al mostrarlas
void mostrar_pila(Pila *pila);
void mostrar_cola(Cola *cola);
 
int main() {
	// No hay que olvidarse de inicializar, porque si no, 
	// no hay manera de determinar si un puntero a memoria
	// dinámica es válido o no...
	Pila pila = {NULL, 0};
	Cola cola = {NULL, NULL, 0};
	tipo dato;
 
	// Para probar que todo funciona perfectamente, hacemos que el
	// usuario introduzca enteros para almacenarlos tanto en una cola
	// como en una pila.
	fprintf(stdout, "Introduzca una serie de numeros (0 para acabar): ");
	fscanf(stdin, "%d", &dato);
	while(0 != dato) {
		agregar_a_pila(&pila, dato);
		agregar_a_cola(&cola, dato);
		fscanf(stdin, "%d", &dato);
	}
 
	// Mostramos la pila y la cola (destruyendo a su vez los datos
	// de las mismas)
	mostrar_pila(&pila);
	fputc('\n', stdout);
	mostrar_cola(&cola);
 
	return 0;
}
 
int agregar_a_pila(Pila *pila, tipo dato) {
	Elemento *elemento;
 
	// Creamos elemento y guardamos datos...
	elemento = malloc(sizeof(Elemento));
	if(NULL == elemento)
		return 0;
 
	elemento->dato = dato;
 
	// Reconfiguramos pila...
	if(NULL == pila->ultimo) {
		elemento->siguiente = NULL;
		pila->num_elementos = 1;
		pila->ultimo = elemento;
	} else {
		elemento->siguiente = pila->ultimo;
		pila->num_elementos += 1;
		pila->ultimo = elemento;
	}
 
	return 1;
}
 
int agregar_a_cola(Cola *cola, tipo dato) {
	Elemento *elemento;
 
	// Creamos elemento y guardamos datos...
	elemento = malloc(sizeof(Elemento));
	if(NULL == elemento)
		return 0;
 
	elemento->dato = dato;
	elemento->siguiente = NULL;
 
	// Reconfiguramos cola...
	if(NULL == cola->primero) {
		cola->num_elementos = 1;
		cola->primero = elemento;
		cola->ultimo = elemento;
	} else {
		cola->ultimo->siguiente = elemento;
		cola->num_elementos += 1;
		cola->ultimo = elemento;
	}
 
	return 1;
}
 
tipo quitar_a_pila(Pila *pila) {
	Elemento *temp;
	tipo dato;
 
	if(NULL != pila->ultimo) {
		dato = pila->ultimo->dato;
		temp = pila->ultimo;
		pila->ultimo = pila->ultimo->siguiente;
		pila->num_elementos -= 1;
		free(temp);
	} else {
		dato = -1;
	}
 
	return dato;
}
 
tipo quitar_a_cola(Cola *cola) {
	Elemento *temp;
	tipo dato;
 
	// Hacemos esta asignación, porque si el primer elemento de la cola y
	// el último son iguales, destruiremos el primer elemento, dejando al último
	// sin memoria asignada, por lo que directamente al último elemento le
	// asignamos NULL para que no haya errores
	if(cola->primero == cola->ultimo)
		cola->ultimo = NULL;
 
	if(NULL != cola->primero) {
		dato = cola->primero->dato;
		temp = cola->primero;
		cola->primero = cola->primero->siguiente;
		cola->num_elementos -= 1;
		free(temp);
	} else {
		dato = -1;
	}
 
	return dato;
}
 
void mostrar_pila(Pila *pila) {
	tipo dato;
 
	while(NULL != pila->ultimo) {
		dato = quitar_a_pila(pila);
		fprintf(stdout, "%d ", dato);
	}
}
 
void mostrar_cola(Cola *cola) {
	tipo dato;
 
	while(NULL != cola->primero) {
		dato = quitar_a_cola(cola);
		fprintf(stdout, "%d ", dato);
	}
}