Assembler-Routine portieren: x86 auf x64

   ASM
                   {x:=SQR(x)-SQR(y)+r:}
                   FLD x            {x laden}
                   FST xalt         {entspr. x:=xalt}
                   FMUL ST,ST       {SQR(x) bilden}
                   FLD y            {y laden}
                   FMUL ST,ST       {SQR(y) bilden}
                   FSUBP ST(1),ST   {SQR(x)-SQR(y) bilden, Stack poppen}
                   FLD r            {r laden}
                   FADDP ST(1),ST   {SQR(x)-SQR(y)+r bilden, Stack poppen}
                   FSTP x           {x speichern}

                   //y:=2*xalt*y+i:
                   FLD Mult          {Mult laden}
                   FLD y             {y laden}
                   FLD xalt          {xalt laden}
                   FMULP ST(2),ST    {Mult*xalt bilden, Stack poppen}
                   FMULP ST(1),ST    {Mult*xalt*y bilden, Stack poppen}
                   FLD i             {i laden}
                   FADDP ST(1),ST    {Mult*y*xalt+i bilden, Stack poppen}
                   FSTP y            {y speichern}

                   INC v            {entspr. dem Pascal-Befehl INC(v) }
                   FLD x             {x laden}
                   FMUL ST,ST        {SQR(x) bilden}
                   FLD y             {y laden}
                   FMUL ST,ST        {SQR(y) bilden}
                   MOV AL,IsBMode    {IsBMode in AL laden}
                   OR AL,AL          {ODER-Verknüfung mit sich selbst, verändert den Wert nicht, setzt aber Flags!}
                   {Die beiden letzten Zeilen stellen einen logischen Vergleich folgender Art dar:}
                   {MOV AL,1 --> entspr. TRUE}
                   {TEST IsBMode,AL}
                   {Die ODER-Verknüfung ist jedoch schneller und benötigt weniger Code!}
                   JNZ  @SetBMode    {bedingter Sprung: "Jump if no zero flag set", d.h. wenn IsBMode=TRUE, d.h.: 1 UND 1 = 1 in TEST}  
                   FADDP ST(1),ST    {SQR(x)+SQR(y) bilden, Stack poppen}
                   JMP @StoreLimit   {unbedingter Sprung, überspringen der nächsten Zeile}
                   @SetBMode:
                   FMULP ST(1),ST  {SQR(x)*SQR(y) bilden, Stack poppen}
                   @StoreLimit:
                   FSTP Limit      {ST(0) in Limit speichern, Stack poppen}

                END;