calculate instruction cound

assignment_assembly/readme.md

@@ -39,6 +39,16 @@ En het test resultaat:
 
 ![screenshot test resultaat](assignment2/rest_result.png)
 
+### How many instructions does it take your procedure to run the code: `multiply(65535, 65535)`?
+
+65535 (decimaal) = 0xFFFF (hex) ofwel 16 eenen in binair.
+
+Voor de loop zijn 3 instructies. 
+
+een interatie van de loop zijn 4 instructies, deze loop wordt netzovaak ald de waarde van `b` uitgevoerd dus 4 * 65535 - 1 = 262139 instructies (de - 1 is voor de laaste iteratie waar die uit de loop springt waardoor de laaste instructie in de loop wordt overgeslagen). 
+
+Na de loop zijn nog 2 instructie, dat een totaal maakt van 262144 instructies
+
 ## A smarter tail recursive multiply algorithm
 
 Voor deze opdracht heb ik niet exect de gegeven C code na gemaakt. Ik heb de twee functies als een geschreven. Hierbij is het argument `m` van `function multiply2` verplaast als laaste argument i.p.v. de eerste en de `if (b == 0)` heb ik verplaats naar `multiply`. 
@@ -54,3 +64,25 @@ De asambly code:
 Het test resultaat:
 
 ![schreenshot testresultaat](assignment5/result.png)
+
+### How many instructions does it take your procedure to run the code: `multiply(65535, 65535)`?
+
+65535 (decimaal) = 0xFFFF (hex) ofwel 16 eenen in binair.
+
+vanaf lable `multiply` duurt het 3 instructie tot de eerste branch instructie. Deze word niet genomen omdat `b` niet 0 is.
+
+hierna komt `multiply2` waar de 2de instrucie een branche is die genomen wordt. b nog geen 0.
+
+`check_even` heeft 3 instructies tot een brance. deze brance wordt altijd genomen omdat `b` in binar alleen maar uit 1en bestaat, dus het schuiven naar rechts (de enige bewerking die gedaan wordt op `b`) verandert bit 1 niet naar 0 voor dat `b` 1 is geweest waneer de loop eindigt.
+
+`odd` heeft 4 instructies, waarna `multiply2` weer word geroepen.
+
+De loop van `multiply2` -> `check_even` -> `odd` word 15 keer gedaan. Voor elk bitje dat 1 is in `b` tot dat er nog maar 1 over is. Deze loop betaat uit 8 instructies dus totaal 120 instructies.
+
+waneer `b` == 1 is net nog 6 instructies tot de `BX.N LR` instrcutie.
+
+Totaal is dat dus 129 instructies (3 van `multiply` + 120 van de loop + 6 van het einde). Dit is signifikant minder dat bij assignment 1, dit waren er 262144 dus deze implementatie is ongeveer 2032 keer minder instructies in dit specifieke geval.
+
+## A smarter power algorithm
+
+