stock sqrt( num ) {
  new div = num;   
  new result = 1;

  while (div > result) {          // end when div == result, or just below
      div = (div + result) / 2;   // take mean value as new divisor   
      result = num / div;   
  } // while

  return div; 
}  

stock dist(vec1[3],vec2[3]) {
    new vec0[3] = {vec1[0] - vec2[0],vec1[1] - vec2[1],vec1[2] - vec2[2]};
    new i = vec0[0] * vec0[0] + vec0[1] * vec0[1] + vec0[2] * vec0[2]
    new j = i;
    new k = 1;
    while(j > k) {
        j = (j + k) / 2;
        k = i / j;
    }
    return j;
}

stock dist(vec1[3],vec2[3]) {
  new k = -1;
  new i = 0;
  for(x=0;x<=2;x++){
    vec1[x] = vec1[x] - vec2[x];
    vec2[x] = vec1[x] * vec1[x];
    k = max(vec2[x],k);
    i +=vec2[x]; 
  }
  new j = i;
  while(j > k) {
    j = (j + k) / 2;
    k = i / j;
  }
  return j;
}

stock dist(vec1[3],vec2[3],accuracy=1) { //Returns the approximate distance between two vectors. A greater accuracy returns a more exact value.
    new vec0[3];
    new i,j,k;
    new l = max(1,accuracy);
    for(i=0;i<3;i++){
        vec0[i] = l * abs(vec1[i] - vec2[i]);
        k = max(vec0[i],k);
        vec0[i] = vec0[i] * vec0[i];
        j +=vec0[i];
    }
    while(j > k) {
        j = (j + k) / 2;
        k = i / j;
    }
    return j / l;
}

stock abs(num) { //Returns the positive value of num.
    if(num > 0) {
        return num;
    }
    return -num;
}

stock distance(UserIndexA,UserIndexV) {
 new Attacker[MAX_NAME_LENGTH];
 new Victim[MAX_NAME_LENGTH];
 new vec1[3],vec2[3];
 new k = -1;
 new i = 0;
 new j = 0;

 playerinfo(UserIndexA,Attacker,MAX_NAME_LENGTH);
 playerinfo(UserIndexB,Victim,MAX_NAME_LENGTH);

 get_userorigin(Attacker,vec1[0],vec1[1],vec1[2]);
 get_userorigin(Victim,vec2[0],vec2[1],vec2[2]);

 for(x=0;x<=2;x++){
  vec1[x] = vec1[x] - vec2[x];
  vec2[x] = vec1[x] * vec1[x];
  k = max(abs(vec1[x]),k);
  i +=vec2[x]; 
 }

 j = i;
 while(j > k) {
  j = (j + k) / 2;
  k = i / j;
 }
 return j;
}

stock abs(num) {
  if(num > 0) {
    return num;
  }
  return -num;
}