uint32_t sqrt1 (uint32_t L)
{
int32_t temp, div;
uint32_t rslt = L;
if (L <= 0) return 0;
else if (L & 0xFFFF0000L)
if (L & 0xFF000000L)
div = 0x3FFF;
else
div = 0x3FF;
else
if (L & 0x0FF00L) div = 0x3F;
else div = (L > 4) ? 0x7 : L;

while (1)
{
temp = L/div + div;
div = temp >> 1;
div += temp & 1;
if (rslt > div) rslt = (uint32_t)div;
else
{
if (L/rslt == rslt-1 && L%rslt==0) rslt--;
return rslt;
}
}
}

uint32_t sqrt2 (uint32_t src)
{
uint32_t wrk;
uint32_t dst;
int i;
dst = 0x8000;
wrk = 0x8000;
for(i=0; i<16; i++)
{
if(dst*dst>src) dst &= ~wrk;
wrk >>= 1;
dst |= wrk;
}
return dst;
}

uint32_t sqrt3 (uint32_t src)
{
uint32_t mask, sqr = 0, temp;
int j=16;

temp = 0xC0000000;
do {
if( src & temp ) break;
temp>>=2;
} while( --j);
if( j==0 ) return 0;
mask = temp & (temp>>1);
do {
temp = sqr | mask;
sqr >>= 1;
if( temp <= src ) {
sqr |= mask;
src -= temp;
}
mask >>= 2;
} while( --j );

return sqr;
}

uint32_t sqrt4 (uint32_t Val)
{
unsigned int bitSqr = 0x40000000;
unsigned int root = 0;

while (bitSqr != 0)
{
if (Val >= (bitSqr + root))
{
Val = Val - (bitSqr + root);
root = (root >> 1) | bitSqr;
}
else
root = (root >> 1);
bitSqr = (bitSqr >> 2);
}
return(root);
}

int TestSqrt(uint32_t(*func)(uint32_t))
{
tick_count_t starttime = get_tick_count();
for (uint32_t i = 0; i < 10000000; i++) {
uint32_t s = func(i);
//Check the value
uint32_t sq = s * s;
if (!((sq == i) ||
(sq > i) && (s-1)*(s-1) < i ||
(sq < i) && (s+1)*(s+1) > i))
{
while (1);
}
}
return get_tick_count() - starttime;
}

unsigned int sqrt(unsigned int v)
{
#define SQRT_ITER(MASK) if (v<r*r) r&=~MASK; r|=(MASK>>1);
unsigned int r=0xC000;
if (v<0x40000000) r=0x4000;
SQRT_ITER(0x4000);
SQRT_ITER(0x2000);
SQRT_ITER(0x1000);
SQRT_ITER(0x0800);
SQRT_ITER(0x0400);
SQRT_ITER(0x0200);
SQRT_ITER(0x0100);
SQRT_ITER(0x0080);
SQRT_ITER(0x0040);
SQRT_ITER(0x0020);
SQRT_ITER(0x0010);
SQRT_ITER(0x0008);
SQRT_ITER(0x0004);
SQRT_ITER(0x0002);
SQRT_ITER(0x0001);
return r;
}


int main()
{
sqrt(1234567890);
return 0;
}

   \   0000000E   01FB01F2           MUL      R2,R1,R1
   \   00000012   9042               CMP      R0,R2
   \   00000014   38BF               IT       CC
   \   00000016   21F48041           BICCC    R1,R1,#0x4000
   \   0000001A   41F40051           ORR      R1,R1,#0x2000

/*
** ISQRT.C
**
** Calculate integer sqare root.
**
** Copyright © MocroGenSf 1992
**
** Created 23-Sep-1992.
**
*/

#include <stdio.h>
#include <stdlib.h>

typedef unsigned int uint;
typedef signed int sint;

typedef unsigned long ulong;
typedef signed long slong;

/* Calculate integer value of sqare root */
uint
isqrt(ulong a)
{ auto ulong x0, x1;
auto slong delta0, delta1;

if (a < 2)
return (a);
delta0 = 0;
x1 = a / 2; /* Initial approximation. */
for (;;)
{ x0 = x1;
x1 = (a / x0 + x0) >> 1;
if ((delta1 = x1 - x0) == 0) return ((uint) x1);
if ((delta0 + delta1) == 0) return ((uint) x0);
delta0 = delta1;
}
}

uint
ihypot(int dx, int dy)
{ return isqrt((slong)dx * (slong)dx + (slong)dy * (slong)dy);
}

void main(void)
{
sint dx, dy;
uint hyp;
char buff[128];
for (;;)
{ printf("dx = ");
//gets(buff, 128);
dx = atoi(buff);
printf("dy = ");
//gets(buff, 128);
dy = atoi(buff);
hyp = ihypot(dx, dy);
printf("ihypot(%d,%d) = %u\n", dx, dy, hyp);
}
}