Based on this C code, could you implement read$\_$record, sift$\_$up$,$ sift$\_$down, heap$\_$insert and heap$\_$remove in asembly code for Windows. Ive done heap$\_$swap and heap$\_$count already$($included in images$).$ Basically commenting out the definition in C code, leaving the prototype, and then implementing it in Assembly.

C:

$/*$

void heap$\_$swap$($int i$,$ int j$)\{$

$$ RECORD $*$temp $=$ heap$[$i$]$;

$$ heap$[$i$]=$ heap$[$j$]$;

$$ heap$[$j$]=$ temp;

$\}$

$*/$

Assembly:

$.$text

$.$globl heap$\_$swap

heap$\_$swap:

# Load the address of heap array into $\%$rax

leaq heap$(\%$rip$),\%$rax # $\%$rax $=$ address of heap

# Load heap$[$i$]($using $\%$rcx as i$)$ into $\%$r$8$

movq $(\%$rax, $\%$rcx$,8),\%$r$8$ # $\%$r$8=$ heap$[$i$]$

# Load heap$[$j$]($using $\%$rdx as j$)$ into $\%$r$9$

movq $(\%$rax, $\%$rdx$,8),\%$r$9$ # $\%$r$9=$ heap$[$j$]$

# Swap heap$[$i$]$ and heap$[$j$]$

movq $\%$r$9,(\%$rax, $\%$rcx$,8)$ # heap$[$i$]=$ heap$[$j$]$

movq $\%$r$8,(\%$rax, $\%$rdx$,8)$ # heap$[$j$]=$ heap$[$i$]$

ret $```$

typedef struct $\{$

char $*$last$\_$name;

char $*$first$\_$name;

long id$\_$number;

$\}$ RECORD;

RECORD $*$read$\_$record$()$;

RECORD $*$read$\_$record$()$

$\{$

char lastname$[100],$ firstname$[100]$;

RECORD $*$p;

long id;

int res $=$ scanf$("\%$s $\%$s $\%$ld$",$ lastname, firstname, $8$id$)$;

if $($res $==$ EOF$)//$ EOF is $-1$

return NLLL;

p $=$ malloc$($sizeof$($RECORD$))$;

p$->$last$\_$name $=$ malloc$($strlen$($lastname$)+1)$;

strcpy$($p$->$last$\_$name, lastname$)$;

p$->$first$\_$name $=$ malloc$($strlen$($lastname$)+1)$;

strcpy$($p$->$first$\_$name, firstname$)$;

p$->$id$\_$number $=$ id;

return p;

##define PARENT$($x$)(($x$-1)>>1)$

##define LEFT$($x$)(($x

##define RIGHT$($x$)(($x

##define SIZE $500$

RECORD $*$heap$[$SIZE$]$;

$//$int heap$\_$count $=8$;

extern int heap$\_$count; $//$ in assembly

void heap$\_$swap$($int i$,$ int j$)$;

void heap$\_$swap$($int i$,$ int j$)\{$

RECORD $*$temp $=$ heap$[$i$]$;

heap$[$i$]=$ heap$[$j$]$;

heap$[$j$]=$ temp;

$\}$

void sift$\_$up$($int i$)$;

void sift$\_$up$($int i$)$

$\{$

while $($i $!=0)\{$

if $($heap$[$i$]->$id$\_$number $>=$ heap$[$PARENT$($i$)]->$id$\_$number$)//$ correct situation, no need to continue

return;

$//$ otherwise, need to swap with parent

heap$\_$swap$($i$,$ PARENT$($i$))$;

i $=$ PARENT$($i$)$;

$\}$

$\}$

$```$

void sift$\_$down$()$;

void sift$\_$domn$()$

$\{$

int i $=0$;

int last$\_$parent $=$ PARENT$($heap$\_$count $-1)$;

int min$\_$child;

while $($i last$\_$parent$)\{$

if $(($RIGHT$($i$)>=$ heap$\_$count$)||$

$($heap$[$LEFT$($i$)]->$id$\_$number heap$[$RIGHT$($i$)]->$id$\_$number$))$

min$\_$child $=$ LEFT$($i$)$;

else

min$\_$child $=$ RIGHT$($i$)$;

if $($heap$[$i$]->$id$\_$number $>$ heap$[$min$\_$child$]->$id$\_$number$)\{$

heap$\_$swap$($i$,$ min$\_$child$)$;

i $=$ min$\_$child;

$\}$

else $//$ done sifting down

return;

$\}$

$\}$

void heap$\_$insert$($RECORD $*$p$)$;

void heap$\_$insert$($RECORD $*$p$)$

$\{$

if $($heap$\_$count $>=$ SIZE$)\{$

printf$("$Error: Heap is full

$")$;

exit$(1)$;

$\}$

heap$[$heap$\_$count$]=$ p;

sift$\_$up$($heap$\_$count$)$;

heap$\_$count$++$;

$\}$

RECORD $*$heap$\_$remove$()$;

RECORD $*$heap$\_$remove$()$

$\{$

if $($heap$\_$count

printf$("$Error: Heap is empty

$")$;

exit$(1)$;

$\}$

RECORD $*$result $=$ heap$[0]$;

heap$\_$count$--$;

heap$[0]=$ heap$[$heap$\_$count$]$;

sift$\_$down$()$;

return result;

$\}$

$.$text

$.$globl heap$\_$swap

$.$globl heap$\_$insert

$.$globl read$\_$record

heap$\_$swap:

Load the address of heap array into $\%$rax

leaq heap$(\%$rip$),\%$rax # $\%$rax $=$ address of heap

Load heap$[$i$]($using $\%$rcx as i$)$ into $\%$r$8$

movq $(\%$rax, $\%$rcx$,8),\%$r$8$ # $\%$r$8=$ heap$[$i$]$

Load heap$[$j$]($using $\%$rdx as j$)$ into $\%$r$9$

movq $(\%$rax, $\%$rdx$,8),\%$r$9$ # $\%$r$9=$ heap$[$j$]$

Swap heap$[$i$]$ and heap$[$j$]$

movq $\%$r$9,(\%$rax, $\%$rcx$,8)$ # heap$[$i$]=$ heap$[$j$]$

movq $\%$r$8,(\%$rax, $\%$rdx$,8)$ # heap$[$j$]=$ heap$[$i$]$

ret

$.$text

$.$globl heap$\_$swap

$.$globl heap$\_$insert

$.$globl read$\_$record

heap$\_$swap:

Load the address of heap array into $\%$rax

leaq heap$(\%$rip$),\%$rax # Xrax $=$ address of heap

Load heap$[$i$]($using $\%$rcx as i$)$ into $\%$r$8$

movq $(\%$rax, $\%$rcx$,8),\%$r$8$ # $\%$r$8=$ heap$[$i$]$

Load heap$[$j$]($using $\%$rdx as j$)$ into $\%$r$9$

movq $(\%$rax, $\%$rdx$,8),\%$r$9$ # $\%$r$9=$ heap$[$j$]$

Swap heap$[$i$]$ and heap$[$j$]$

movq $\%$r$9,(\%$rax, $\%$rcx$,8)$ # heap$[$i$]=$ heap$[$j$]$

movq $\%$r$8,(\%$rax, $\%$rdx$,8)$ # heap$[$j$]=$ heap$[$i$]$

ret

$.$data

$.$globl heap$\_$count

heap$\_$count:

$.$long $0$ # Initialize heap$\_$count to $0$