import java.io.*;
import java.util.*;
import java.net.*;
//_____________________________________________________________
public class math
{ 
//_____________________________________________________________
public static final void main(String[] args) throws Exception
{
   String s0 = "3";
   if (args.length > 0) s0 = args[0];
   String s1 = "3";
   if (args.length > 1) s1 = args[1];
   String s2 = "3";
   if (args.length > 2) s2 = args[2];
   long t1 = System.nanoTime();
   math mth = new math();
   //mth.sqrt_old(args);
//   mth.sqrt2(args);
   //mth.div(s0, s1, s2);
   //mth.pi_old(args);
   //mth.pi2_old(args);
   //mth.e_old(args);
   mth.start(args);
   //mth.eto_old(Double.parseDouble(args[0]), Integer.parseInt(args[1]));
   //mth.ln_old(Double.parseDouble(args[0]), Integer.parseInt(args[1]));
   //mth.ln2_old(Double.parseDouble(args[0]), Integer.parseInt(args[1]));
   //mth.xtoy_old(s0, s1, s2);
   long t2 = System.nanoTime();
   System.out.println("seconds = " + ((t2-t1)/1e9));
}
//_____________________________________________________________
math() throws Exception 
{
}
//___________________________________________________________________________
String sqrt_old(String[] args)
{
   int pos = 1;
   String val = "645";
   if (args.length > 0) val = args[0];
   int significant = 3;
   if (args.length > 1) significant = Integer.parseInt(args[1]);
   boolean even = false;
   int width = val.length();
   double d = (double)width / 2.0;
   if (d == (int)d) 
   {
      even = true;
      pos = 2;
   }
   //System.out.println(even);
   String str1 = "";
   long num2 = 0;
   if (even) str1 = val.substring(0,2);
   else str1 = val.substring(0,1); // 6
   num2 = (int)Math.sqrt(Integer.parseInt(str1)); // 2
   String str2 = Long.toString(num2);
   long num4 = 0;
   for (int i = 0; i < significant; i++)
   {
      long num3 = 20 * num2; // 40
      if (i == 0) num4 = Integer.parseInt(str1) - num2 * num2; // 2
      String str5 = "";
      if (val.length() >= pos + 2) 
      {
         str5 = Long.toString(num4) + val.substring(pos, pos+2);
         // 245
      }
      else
      {
         str5 = Long.toString(num4) + "00";  
      }
      long num5 = Long.parseLong(str5);
      int j = 0;
      for (j = 0; j < 10; j++)
      {
         if (((num3 + j) * j) >= num5) break;
      }
      if (j == 0) break;
      long num6 = j - 1; // 5
      str2 = Long.toString(num2) + Long.toString(num6);
      num3 += num6; // 45
      long num7 = num3 * num6; // 225
      num4 = Long.parseLong(str5) - num7; // 20
      pos += 2;
      num2 = Long.parseLong(str2);
   }
   System.out.println(str2);
   return(str2);
}
//___________________________________________________________________________
String sqrt2(String[] args) throws Exception
{
   int pos = 1;
   String val = "645";
   if (args.length > 0) val = args[0];
   int significant = 3;
   if (args.length > 1) significant = Integer.parseInt(args[1]);
   boolean even = false;
   int width = val.length();
   double d = (double)width / 2.0;
   if (d == (int)d) 
   {
      even = true;
      pos = 2;
   }
   String str1 = "";
   long num2 = 0;
   if (even) str1 = val.substring(0,2);
   else str1 = val.substring(0,1); // 6
   num2 = (int)Math.sqrt(Integer.parseInt(str1)); // 2
   String str2 = Long.toString(num2);
   long num4 = 0;
   String str4 = "0";
   int count = 0;
   for (int i = 0; i <= significant - 2; i++)
   {
      if (count++ >= 1000)
      {
         System.out.print(".");
         count = 0;
      }
      String str3 = mul("20", str2);
      if (i == 0) 
      {
         num4 = Integer.parseInt(str1) - num2 * num2; // 2
         str4 = Long.toString(num4);
      }
      String str5 = "";
      if (val.length() >= pos + 2) 
      {
         str5 = str4 + val.substring(pos, pos+2);
      }
      else
      {
         str5 = str4 + "00";
      }
      if (allzero(str5)) break;
      int j = 0;
      for (j = 0; j < 10; j++)
      {
         String js = Integer.toString(j);
         if (greaterequal(mul(add(str3,js),js),str5)) break;
      }
      if (j == 0) break;
      String str6 = Integer.toString(j-1);
      str2 = str2 + str6;
      str3 = add(str3,str6);
      String str7 = mul(str3,str6);
      str4 = sub(str5,str7);
      pos += 2;
   }
   data.saveFile("sqrt/sqrt" + val + ".txt", str2, false);
   return(str2);
}
//___________________________________________________________________________
boolean allzero(String str)
{
   byte[] bb = str.getBytes();
   for (int i = 0; i < bb.length; i++)
   {
      if (bb[i] != '0') 
      { 
         return(false);
      }
   }
   return(true);
}
//___________________________________________________________________________
void start(String[] args) throws Exception
{
   int start = 2;
   if (args.length > 0) start = Integer.parseInt(args[0]);
   int end = 2;
   if (args.length > 1) end = Integer.parseInt(args[1]);
   String[] args2 = new String[2];
   args2[1] = "304805";
   for (int i = start; i < end; i++)
   {
      System.out.print(i + " ");
      args2[0] = Integer.toString(i);
      sqrt2(args2);
   }
}
//___________________________________________________________________________
boolean greaterequal(String num1, String num2)
{
   byte[] bb1 = num1.getBytes();
   byte[] bb2 = num2.getBytes();
   byte[] bc1 = reverse(bb1);
   byte[] bc2 = reverse(bb2);
   if (bc1.length > bc2.length) return(true);
   if (bc1.length < bc2.length) return(false);
   for (int i = bc1.length-1; i >= 0; i--)
   {
      if (bc1[i] > bc2[i]) return(true);
      else if (bc1[i] < bc2[i]) return(false);
   }
   return(true);
}
//___________________________________________________________________________
public String add(String num1, String num2)
{
   StringBuffer buf = new StringBuffer();
   byte[] bb1 = num1.getBytes();
   byte[] bb2 = num2.getBytes();
   byte[] out;
   byte[] bc1 = reverse(bb1);
   byte[] bc2 = reverse(bb2);
   int carry = 0;
   int len = bc1.length;
   if (bc2.length > len) len = bc2.length;
   out = new byte[len + 1];
   int i = 0;
   byte[] out2 = new byte[0];
   for (i = 0; i < len; i++)
   {
      int val1 = 0;
      if (bc1.length > i) val1 = bc1[i] - '0';
      int val2 = 0;
      if (bc2.length > i) val2 = bc2[i] - '0';
      int val3 = val1 + val2 + carry;
      out[i] = (byte)((byte)(val3 % 10) + (byte)'0');
      
      carry = (int)(val3 / 10.0);
   }
   if (carry == 0)
   {
      byte[] out4 = new byte[out.length - 1];
      for (int j = 0; j < out4.length; j++)
      {
         out4[j] = out[j];
      }
      out2 = reverse(out4);
   }
   else
   {
      out[i] = (byte)((byte)carry + (byte)'0');
      out2 = reverse(out);
   }
   //byte[] out2 = reverse(out);
   String out3 = new String(out2);
   //System.out.println(out3);
   return(out3);
}
//___________________________________________________________________________
String sub(String num1, String num2)
{
   StringBuffer buf = new StringBuffer();
   byte[] bb1 = num1.getBytes();
   byte[] bb2 = num2.getBytes();
   byte[] out;
   byte[] bc1 = reverse(bb1);
   byte[] bc2 = reverse(bb2);
   int carry = 0;
   int len = bc1.length;
   if (bc2.length > len) len = bc2.length;
   out = new byte[len + 0];
   int i = 0;
   byte[] out2 = new byte[0];
   for (i = 0; i < len; i++)
   {
      int val1 = 0;
      if (bc1.length > i) val1 = bc1[i] - '0';
      int val2 = 0;
      if (bc2.length > i) val2 = bc2[i] - '0';
      int val3 = val1 - val2 - carry;
      if (val3 < 0)
      {
         val3 += 10;
         carry = 1;
      }
      else
      {
         carry = 0;  
      }
      out[i] = (byte)((byte)(val3 % 10) + (byte)'0');
      
      //carry = (int)(val3 / 10.0);
   }
   if (carry > 0)
   {
      System.out.println("negative");
   }
   for (int j = out.length - 1; j >= 1; j--)
   {
      if (out[j] > '0') break;
      len = j;
   }
   byte[] out4 = new byte[len];
   for (int j = 0; j < out4.length; j++)
   {
      out4[j] = out[j];
   }
   out2 = reverse(out4);
   //byte[] out2 = reverse(out);
   String out3 = new String(out2);
   //System.out.println(out3);
   return(out3);
}
//___________________________________________________________________________
String mul(String num1, String num2)
{
   StringBuffer buf = new StringBuffer();
   byte[] bb1 = num1.getBytes();
   byte[] bb2 = num2.getBytes();
   byte[] out;
   byte[] out2;
   byte[] bc1 = reverse(bb1);
   byte[] bc2 = reverse(bb2);
   int carry = 0;
   int len = bc1.length + bc2.length;
   if (bc2.length > len) len = bc2.length;
   out = new byte[bc1.length + bc2.length];
   int[] intout = new int[out.length];
   for (int i = 0; i < bc1.length; i++)
   {
      for (int j = 0; j < bc2.length; j++)
      {
         intout[j+i] += (bc1[i] - '0') * (bc2[j] - '0');
      }
   }
   for (int i = 0; i < out.length - 1; i++)
   {
      //if (intout[i] > 99) System.out.println("ERROR");
      intout[i+1] += (int)(intout[i] / 10.0);
      intout[i] = intout[i] % 10;
   }
   for (int i = 0; i < intout.length; i++)
   {
      out[i] = (byte)(intout[i] + '0');
   }



   for (int j = out.length - 1; j >= 1; j--)
   {
      if (out[j] > '0') break;
      len = j;
   }
   byte[] out4 = new byte[len];
   for (int j = 0; j < out4.length; j++)
   {
      out4[j] = out[j];
   }
   out2 = reverse(out4);
   //byte[] out2 = reverse(out);
   String out3 = new String(out2);
   //System.out.println(out3);
   return(out3);
}
//___________________________________________________________________________
String div(String num1, String num2, String sig)
{
   int significant = Integer.parseInt(sig);
   StringBuffer bufout = new StringBuffer();
   StringBuffer buf = new StringBuffer();
   byte[] bb1 = num1.getBytes();
   byte[] bb2 = num2.getBytes();
   byte[] out;
   byte[] out2;
   //byte[] bc1 = reverse(bb1);
   //byte[] bc2 = reverse(bb2);
   for (int i = 0; i < significant; i++)
   {
       if (i < bb1.length)
       {
          buf.append((char)bb1[i]);
       }
       else
       {
          if (buf.toString().equals("0")) break;
          buf.append("0");
       }
//System.out.println("A " + buf.toString() + " " + num2);
       if (greaterequal(buf.toString(), num2))
       {
//System.out.println("B");
          for (int k = 9; k >= 0; k--)
          {
             String a = mul(num2, Integer.toString(k));
//System.out.println("D " + k + " " + buf.toString() + " " + a);
             if (greaterequal(buf.toString(),a))
             {
//System.out.println("E " + k + " " + buf.toString() + " " + a);
                bufout.append(Integer.toString(k));
                String str = buf.toString();
                buf = new StringBuffer();
                buf.append(sub(str,a));
//System.out.println("F " + buf.toString());
                break;
             }
          }
       }
       else
       {
//System.out.println("C");
         if (!bufout.toString().equals("")) bufout.append("0");
       }
   }
   System.out.println("answer = " + bufout.toString());
   return(bufout.toString());
}
//___________________________________________________________________________
byte[] reverse(byte[] bb)
{
   byte[] bd = new byte[bb.length];
   int pos = 0;
   for (int i = bb.length - 1; i >= 0; i--)
   {
       bd[pos++] = bb[i];  
   }
   return(bd);
}
//___________________________________________________________________________
String pi2_old(String[] args)
{
   // pi / 4 = 1 - 1/3 + 1/5 - 1/7 + 1/9
   int num = 3;
   if (args.length > 0) num = Integer.parseInt(args[0]);
   double total = 0;
   int flop = 1;
   for (int i = 1; i < num * 2; i += 2)
   {
      double ii = (double)i;
      total += (flop / ii);
      flop = flop * -1;
   } 
   System.out.println((total*4));
   return(Double.toString(total));
}
//___________________________________________________________________________
String pi_old(String[] args)
{
   // pi = 3 + (4/(2x3x4)) - (4/(4x5x6)) + (4/(6x7x8)) ...
   int num = 3;
   if (args.length > 0) num = Integer.parseInt(args[0]);
   double total = 3.0;
   int flop = 1;
   for (int i = 2; i < num * 2; i+= 2)
   {
      double ii = (double)i;
      total += flop * (4.0 / (i*(i+1.0)*(i+2.0)));
      flop = flop * -1;
   }
   System.out.println(total);
   return(Double.toString(total));
}
//___________________________________________________________________________
String pi(String[] args)
{
   // pi = 3 + (4/(2x3x4)) - (4/(4x5x6)) + (4/(6x7x8)) ...
   int num = 3;
   if (args.length > 0) num = Integer.parseInt(args[0]);
   String total = "3";
   int flop = 1;
   for (int i = 2; i < num * 2; i+= 4)
   {
      //double ii = (double)i;
      //total += flop * (4.0 / (i*(i+1.0)*(i+2.0)));
      String a = Integer.toString(i);
      String b = Integer.toString(i+1);
      String c = Integer.toString(i+2);
      String d = mul(c,mul(a,b));
      String e = div("4",d, "10");
      total = add(total,e);
      String f = Integer.toString(i+3);
      String g = Integer.toString(i+4);
      String h = mul(g,mul(f,c));
      String ii = div("4",h, "10");
      total = sub(total, ii);
      //flop = flop * -1;
   }
   System.out.println(total);
   return(total);
}
//___________________________________________________________________________
String e_old(String[] args)
{
   // e = 1/0! + 1/1! + 1/2! ...
   int num = 3;
   if (args.length > 0) num = Integer.parseInt(args[0]);
   double total = 0;
   for (int i = 0; i < num; i++)
   {
      double ii = (double)i;
      total += 1 / fact_old(i);
   }
   System.out.println(total);
   return(Double.toString(total));
}
//___________________________________________________________________________
double fact_old(int num)
{
   int total = 1;
   if (num == 0) return(1.0);
   for (int i = 1; i <= num; i++)
   {
      total *= i;
   }
   return(total);
}
//___________________________________________________________________________
double xtoy_old(String s0, String s1, String s2)
{
   // x^y = e ^ (y X ln(x, significant))
   double x = Double.parseDouble(s0);
   double y = Double.parseDouble(s1);
   int significant = Integer.parseInt(s2);
   double a = ln_old(x, significant);
   double b = y * a;
   double c = eto_old(b, significant);
   System.out.println(c);
   return(c);
}
//___________________________________________________________________________
double eto_old(double num, int significant)
{
   // e^x = 1 + x + x^2/2! + x^3/3! ...
   double a = 1;
   double b = 1;
   double c = 0;
   double total = 1;
   for (int i = 1; i < significant; i++)
   {
      a *= num; 
      b *= i;
      c = a/b;
      total += c;
      //System.out.println(i + " " + a + " " + b + " " + c + " " + total);
      
   }
   System.out.println(total);
   return(total);
}
//___________________________________________________________________________
double ln2_old(double num, int significant)
{
   // ln(1+x) = x - x^2/2 + x^3/3 - x^4/4 ...
   // e^x = 1 + x + x^2/2! + x^3/3! ...
   double a = 1;
   double b = 1;
   double c = 0;
   double total = 0;
   int flip = 1;
   for (int i = 1; i < significant; i++)
   {
      a *= num; 
      b = i;
      c = a/b;
      total += c * flip;
      flip *= -1;
      //System.out.println(i + " " + a + " " + b + " " + c + " " + flip + " " + total);
      
   }
   System.out.println(total);
   return(total);
}
//___________________________________________________________________________
double ln_old(double z, int significant)
{
   // ln(z) = 2 X Sum(0 to n) (1/(2n+1)) X (((z-1)/(z+1))^(2n+1))
   double total = 0;
   for (int n = 0; n < significant; n++)
   {
      int m = 2*n+1;
      double a = 1.0/m;
      double b = (z-1.0) / (z+1.0);
      double c = Math.pow(b,m);
      double d = a * c;
      total += d;
      //System.out.println(n + " " + m + " " + a + " " + b + " " + c + " " + d + " " + total);
      //System.out.println(total);
   }
   total *= 2;
   System.out.println("=" + total);
   return(total);
}
//___________________________________________________________________________
double ln3(double z, int significant)
{
   // ln(n+1) = ln(n) + 1/n - 1/(2n^2) + 1/(3n^3) ...
   return(0.0);
}
//___________________________________________________________________________
String power(String num, String s1)
{
   int pow = Integer.parseInt(s1);
   String total = "1";
   for (int i = 0; i < pow; i++)
   {
      //total *= num;
      total = mul(total, num);
   }
   return(total);
}
}//__________________________________________________________________________