Can't find bad memory indicated by valgrind - memory-leaks

Question

I'm having trouble with valgrind.
I wrote an assembly program that simulates a game as part of an assignment and I only allocated dynamic memory once for a 2d array called drone_stats. I'm not getting any memory leaks since I did free all memory , but I am getting a bunch of other errors. namely:
Use of uninitialised value of size 4
Uninitialised value was created by a stack allocation
and they all come from this file:
global N
global R
global K
global d
global seed
global drone_stats
global resume
global CORS
global CODEP
global SPP
global seed_dword
global numco
global random
global quit
CODEP equ 0
SPP equ 4
section .rodata
format_int: db "%d"
format_float: db "%f"
section .bss
N: resb 4 ; number of drones
R: resb 4 ; number of rounds per elimination
K: resb 4 ; number of steps per print
d: resb 4 ; max distance away from target that allows destruction
seed: resb 4 ; intial seed for random number
drone_stats: resb 4 ; pointer to an array of pointer, each pointing the an array of the following format:
; [activated: boolean, id: int, x_pos: float, y_pos: float, speed: float, angle: float, score: int]
; drone_i_arr: [[drone_stats]+ drone_id(i)]
SPMAIN: resb 4
SPT: resb 4
CURR: resb 4
STKSZ equ 16*1024
STK1: resb STKSZ
STK2: resb STKSZ
STK3: resb STKSZ
STK4: resb STKSZ
section .data
numco: dd 4
PRINTER: dd f_printer
dd STK1+STKSZ
DRONE: dd f_drone
dd STK2+STKSZ
TARGET: dd f_target
dd STK3+STKSZ
SCHEDULER: dd f_scheduler
dd STK4+STKSZ
CORS: dd PRINTER ; id 0
dd DRONE ; id 1
dd TARGET ; id 2
dd SCHEDULER ; id 3
temp_macro: dd 4
; macro to free memory allocated by param
%macro free_array 1
pushad
push %1
call free
add esp, 4
popad
%endmacro
; macro to allocate %1 blocks of %2 bytes each , and return a pointer to allocated memory in eax
%macro allocate 2
pushad
push %2
push %1
call calloc
add esp, 8
mov [temp_macro], eax
popad
mov eax, [temp_macro]
%endmacro
; macro to read an input from the user according to format %2 and store in variable %1
%macro read_formatted 3 ; sscanf(%3, %2, %1)
pushad
push dword %1
push %2
push %3
call sscanf
add esp, 12
popad
%endmacro
; macro to initialize a single co-routine with id %1
%macro init_co 1
pushad
mov ebx, %1
mov ebx, [4*ebx+CORS]
mov eax, [ebx+CODEP]
mov [SPT], esp
mov esp, [ebx+SPP]
push eax ; push into co-routine's stack
pushfd
pushad
mov [ebx+SPP], esp
mov esp, [SPT]
popad
%endmacro
;macro to generate a number in range of 0 - %1 and to store it's value in %2
%macro generate_random 2
push dword %1
call calc_range
add esp, 4
mov dword [%2], eax
%endmacro
;============================================================::CODE::================================================================
section .text
;funcs
global main
extern f_drone
extern f_printer
extern f_target
extern f_scheduler
extern calc_range
extern calloc
extern free
extern sscanf
;vars
extern target_x
extern target_y
;================================::AUXILIARY FUNCTIONS::===================================
resume: ; save state of current co-routine
pushfd
pushad
mov edx, dword [CURR]
mov dword [edx + SPP], esp ; save current ESP
do_resume: ; load ESP for resumed co-routine
mov esp, dword [ebx + SPP]
mov dword [CURR], ebx ; get the current co routine
popad ; restore resumed co-routine state
popfd
ret ; "return" to resumed co-routine
;--------------------------------
; void quit()
; function to execute a syscall exit right after freeing all memory allocated by the program
quit:
push ebp
mov ebp, esp
mov eax, [drone_stats]
mov ecx, dword [N]
.loop:
mov ebx, [eax]
free_array ebx
add eax, 4
loop .loop
mov eax, [drone_stats]
free_array eax
mov eax, 1
mov ebx, 0
int 0x80
mov esp, ebp
pop ebp
;--------------------------------
; void random()
;
random:
push ebp ; function prologue
mov ebp, esp
pushad
mov edx, 16
seed_loop:
mov ebx,0
mov eax,0
mov ecx,0
mov bx, word [seed]
mov cx, 1
and cx, bx ; check if the 16 bit is '1' or '0'
shr bx, 2 ; get the 14 bit
mov ax, 1
and ax, bx ;check the 14 but
xor cx, ax
shr bx, 1 ; get the 13 bit
mov ax,1
and ax, bx ; check the 13 bit
xor cx, ax
shr bx,2 ; get the 11 bit
mov ax,1
and ax, bx ; check 11 bit
xor cx , ax
mov ax , word [seed]
shr ax, 1
shl cx, 15 ; move result to msb
or ax, cx
mov word [seed], ax
dec edx
cmp edx ,0
jne seed_loop
popad
mov esp, ebp ; function epilogue
pop ebp
ret
main:
push ebp ; function prologue
mov ebp, esp
pushad
; get command-line arguments: <N> <R> <K> <d> <seed>
mov ecx , dword [ebp+8] ; ecx = argc
mov ecx, dword [ebp+12] ; ecx points to argv[0] = program name
mov ebx , dword [ecx+4] ; ebx is a pointer to N(num_drones)
read_formatted N, format_int, ebx
mov ebx , dword [ecx+8] ; ebx is a pointer to R(number of rounds before elimination, Round = N steps)
read_formatted R, format_int, ebx
mov ebx , dword [ecx+12] ; ebx is a pointer to K(number of steps before printing the board)
read_formatted K, format_int, ebx
mov ebx , dword [ecx+16] ; ebx is a pointer to d(the maximum distance)
read_formatted d, format_float, ebx
mov ebx , dword [ecx+20] ; ebx is a pointer to seed(LFSR initialization value)
read_formatted seed, format_int, ebx
; initialize all co-routines
mov ecx, [numco]
xor ebx, ebx ; id of current co-routine
.init_cos:
init_co ebx
inc ebx
loop .init_cos
; intialize target
generate_random 100, target_x ; x: random [0~100]
generate_random 100, target_y ; y: random [0~100]
; allocate an array of pointers. each pointer will point to an array of size 7 that holds all the stats of a single drone:
; step1: allocate an array of N (num of drones) pointers
; step2: allocate N arrays of size 7 and have each one pointed to by a corresponding pointer in the first array
allocate dword [N], 4
mov [drone_stats], eax
mov ecx, [N]
mov ebx, [drone_stats]
.loop_create:
allocate 7, 4 ; allocate an array of size 7 to hold the stats of a drone
mov [ebx], eax ; ebx = drone_stats + i*4, that's a pointer to newly allocated memory for each drone
add ebx, 4
loop .loop_create
; initialize drones
mov ecx, dword [N]
mov edx, dword [drone_stats]
xor edi, edi
; initial stats of drone : [mode: on, id: edi, x: random, y: random, speed: random, angle: random, score: 0]
.loop_init:
mov ebx, [edx] ; array of i'th drone
mov dword [ebx], 1 ; mode: ON
add ebx, 4
mov dword [ebx], edi ; id: edi
add ebx, 4
generate_random 100, ebx ; x: random [0~100]
add ebx, 4
generate_random 100, ebx ; y: random [0~100]
add ebx, 4
generate_random 100, ebx ; speed: random [0~100]
add ebx, 4
generate_random 360, ebx ; angle: random [0~360]
add ebx, 4
mov dword [ebx], 0 ; score: 0
add edx, 4 ; next drone
inc edi ; next id
loop .loop_init
;; printing the board before playing
mov ebx, [CORS]
jmp do_resume
startCo:
pushad
mov [SPMAIN], esp
mov ebx, [CORS +12]
jmp do_resume
popad
mov esp, ebp
pop ebp
ret
Can anyone point to the problem? Thanks ahead!