extern	printf



		
	section	.data
hp:	dd	heap			
lp:	dd	1
fmt1:	db	"%s",10,0  		

section .bss
heap:	resb	20000
list:	resd	1000
q:	resd	1			
i:	resd	1			
		


	section	.text
	global clear
clear:
        push	ebp			
        mov	ebp, esp		
        push	ebx			
        push	edi
	      push	esi

        mov	edi,[ebp+8]		
        mov	EAX,[edi]
        mov	EAX,0	
        mov ecx, [edi]
        mov ecx, eax
        mov [edi], ecx		
        mov	[edi],EAX		
        mov ecx, [edi+4]
        mov ecx, eax
        mov [edi+4], ecx		
        mov	[edi+4],EAX		

        pop	esi			
				pop	edi			
        pop	ebx
        mov	esp,ebp			
        pop	ebp
        ret				
; }






	global push_front

push_front:				

	push    ebp                  	
  mov     ebp, esp             
  push    ebx                  	
  push    edi
  push    esi


	
	mov edi,[ebp+4*2]        		
	mov ecx,0h	
	cmp [edi],ecx			
	jne listReplace		
	mov ecx,[lp]
	mov [edi], ecx			
	mov [edi+4],ecx			   	
     	mov ebx, 0h
     	mov [list+4*ecx], ebx		
     	mov [list+4*ecx +4], ebx	
	jmp updateLp


listReplace:
	mov ecx, [edi]		
	mov [i],ecx
        mov ebx, [lp]			
	mov[edi], ebx     		
     	mov [list+ebx*4], ecx		
     	mov ecx, 0h			   
     	mov [list +4*ebx + 4], ecx  
     	mov [list +4*ecx +4], ebx 


updateLp:

     	mov ebx, [lp]			
     	mov ecx, [hp]			
     	mov [list+4*ebx + 8], ecx	
     	add ebx, 3			
     	mov [lp], ebx			
     	mov esi,[ebp+12]
     	mov [q], esi			
     	mov ecx, [q]
     	mov edx, [ecx]
     	cmp edx, 0h
     	je pfEnd


incrementHp:

     mov ebx, [hp]			
     mov edx, [ecx]			
     mov [ebx], edx			
     inc ebx 				
     mov [hp], ebx			
     inc ecx				
     mov [q], ecx			
     mov edx, [ecx]
     cmp edx, 0h				
     jne incrementHp			

pfEnd:

     	mov ecx, 0h			
     	mov EAX, [hp]			
     	mov [EAX], ecx			
     	inc EAX				
     	mov [hp], EAX			
 

	      pop	esi			
	      pop	edi			
        pop	ebx
        mov	esp,ebp			
        pop	ebp
        ret				
	
	

	global pop_back

pop_back:				

	
	      push	ebp			
        mov	ebp, esp		
        push	ebx		
        push	edi
	       push	esi
	
	
	mov  edi,[ebp+8]		
	mov  ecx,0h	
	cmp [edi+4], ecx		
	jne popbackIF
	ret
	
	

popbackIF:	
	
	
	      mov 	ebx,[edi]
	      mov   EAX, [edi+4]
	      cmp 	EAX ,ebx		
	      jne 	pbLoop2	
	
	      mov  ecx, 0h
        mov	[edi],ecx		
        mov	[edi+4],ecx		
	      ret				
	


pbLoop2:

	
		
  	mov	ecx, [edi+4]		        
  	mov	ecx, [list+4*ecx+4]	      
  	mov	[edi+4], ecx		
  	mov 	ebx,0h
	mov 	[list+4*ecx], ebx	


	pop	esi			
	pop	edi			
        pop	ebx
        mov	esp,ebp			
        pop	ebp
        ret				


	
	
	




	global	print
print: 					
	
	
				push	ebp			
        mov	ebp, esp		
        push	ebx			
        push	edi
				push	esi
	
	
	
        mov	edi,[ebp+8]		
        mov     edi,[edi]    		
        
	
printLoop:			
        
        mov     ecx, 0h;
        cmp     edi,ecx			
        je      printExit
        mov	esi,[list+4*edi+8]	
				push    dword esi		
        push    dword fmt1
        call	printf
        add	esp,8
        mov     edi,[list+4*edi]	
        jmp     printLoop
        
;   }
printExit:
				pop	esi			
				pop	edi			
        pop	ebx
        mov	esp,ebp			
        pop	ebp
        ret				

	






	global pop_front

pop_front:				


	push	ebp			
        mov	ebp, esp		
        push	ebx			
        push	edi
	push	esi
	
	
	mov  edi,[ebp+8]		
	mov  ecx,0h


	cmp [edi], ecx			
	jne LoopCompare
	ret
	
	
LoopCompare:
        
        mov 	ecx, [edi+4]
	cmp 	[edi],ecx		
	jne 	replaceLoop
	mov	ecx,0h			
        mov	[edi],ecx		
	mov	[edi+4],ecx		
	ret			
	
replaceLoop:
	
	mov 	ecx, [i]
;	mov 	edi,[ebp+8]		
        mov 	ecx,[edi]    		
	mov 	ecx, [list+4*ecx]	      
	mov 	[edi],ecx		      
	mov 	ebx,0h
	mov 	[list+4*ecx +4], ebx	  
	
	
	pop	esi		
	pop	edi			
        pop	ebx
        mov	esp,ebp			
        pop	ebp
        ret				; return


	
	global push_back
push_back:

        push    ebp      ;  save ebp
        mov     ebp, esp ;  ebp is callers stack
        push    ebx      ;  save registers
        push    edi
        push    esi

        mov     edi,[ebp+8]     ; get address of L into edi
        mov     edx, [edi]      ; grab L[0];
        cmp     edx, 0
        jne     else2           ; check if list is empty and goto block       if (L[0] == 0)

if2:
        mov     dword ecx, [lp]         ; L[0] = lp;
        mov     dword [edi], ecx

        mov     dword ecx, [lp]         ; L[1] = lp;
        mov     dword [edi+4], ecx
                                ;
        mov     dword [list+4*ecx], 0         ; list[lp] = 0;
        mov     dword [list+4*ecx+4], 0       ; list[lp+1] = 0;
        jmp     endif2


else2:
        mov     dword ecx, [edi+4]              ; i = L[1];
        mov     dword [i], ecx

        mov     dword ecx, [lp]                 ; L[1] = lp;
        mov     dword [edi+4], ecx

        mov     dword EAX, [lp]
        mov     dword [list+4*EAX], 0         ; list[lp]=0;

        mov     dword ecx, [i]                  ; list[lp+1]=i;
        mov     dword [list+4*EAX+4], ecx

        mov     dword EAX, [i]
        mov     dword ecx, [lp]                 ; list[i]=lp;
        mov     dword [list+4*(EAX)], ecx


endif2:

                mov ebx, [lp]
                mov EAX, [hp]
                mov [list + 4*ebx + 8], EAX ;  list[lp + 2] = hp
                add ebx, 3
                mov [lp], ebx   ;  lp = lp + 3

                mov esi, [ebp+12]

                mov [q], esi    ;  q = s
                mov EAX,  [q]
                mov edx, [EAX]
                cmp edx, 0      ;  while *q isn't 0 start loop

                je end_w2



cpyhp2:

                mov ebx, [hp]
                mov edx, [EAX]
                mov [ebx], edx  ;  *hp = *q
                inc ebx
                mov [hp], ebx   ;  hp++

                inc EAX
                mov [q], EAX    ;   q++
                mov edx, [EAX]
                cmp edx, 0      ;  while *q isn't 0 loop again
                jne cpyhp2

                mov EAX, 0
                mov ecx, [hp]
                mov [ecx], EAX
                inc ecx
                mov [hp], ecx


end_w2:

                mov EAX, [hp]
                mov dword [EAX], 0      ;
                inc EAX
                mov [hp], EAX


        pop     esi             ;  restore registers
        pop     edi     ;  in reverse order
        pop     ebx
        mov     esp,ebp ;  restore callers stack frame
        pop     ebp
        ret             ;  return

; }