title: What does "java result" means?
body: <p>after execution of my program written in java I see this output: </p>
  
  <blockquote>
    <p>java result: 2147483647 </p>
  </blockquote>
  
  <p>What does this number means anyway? This is the code. Tt should actually run random test cases on an ACM problem solution! no way to stop normally! and when I stop it manually I see this output:</p>
  
  <blockquote>
    <p>Java Result: 2147483647<br>
    BUILD SUCCESSFUL (total time: 8 minutes 49 seconds)</p>
  </blockquote>
  
  <p>I just want to know what does that number means?</p>
  
  <pre><code>package acm;
  import java.util.Random;
  import java.util.Scanner;
  import java.util.Vector;
  public class mamoth {
  static Scanner input = new Scanner(System.in);
  public static String planets;
  public static int H;
  public static int A;
  public static Random random = new Random();
  
  public static void main(String []args)
  {
      while(!(planets = /*input.nextLine()*/Integer.toString(random.nextInt(10)+1) + " " + Integer.toString(random.nextInt(10)+1)).equals("0 0")){
          System.out.println(planets);
      //while(!(planets = input.nextLine()).equals("0 0")){
          int index;
          index = planets.indexOf(' ');
          H = Integer.valueOf(planets.substring(0, index));
          A = Integer.valueOf(planets.substring(index+1));
          Vector&lt;Integer&gt; humanPlanets = new Vector&lt;Integer&gt;();
  
          String temp = "1 0";
          for(int i=0;i&lt;H-1;i++){
              temp += " 1 0";
          }
  
          planets = /*input.nextLine()*/temp;
          System.out.println(planets);
          //planets = input.nextLine();
         int index1 = 0;
         int index2;
         while((index2 = planets.indexOf(' ',index1))!=-1){
             humanPlanets.addElement(Integer.valueOf(planets.substring(index1, index2)));
             index1= index2+1;
         }
         humanPlanets.addElement(Integer.valueOf(planets.substring(index1)));
  
         Vector&lt;Integer&gt; aliasPlanets = new Vector&lt;Integer&gt;();
  
         temp = "0 0";
          for(int i=0;i&lt;A-1;i++){
              temp += " 0 0";
          }
  
         planets = /*input.nextLine()*/temp;
          System.out.println(planets);
         //planets = input.nextLine();
         index1 = 0;
         while((index2 = planets.indexOf(' ',index1))!=-1){
             aliasPlanets.addElement(Integer.valueOf(planets.substring(index1, index2)));
             index1= index2+1;
         }
         aliasPlanets.addElement(Integer.valueOf(planets.substring(index1)));
  
         int[][] distance = new int[H][A];
         for(int i=0;i&lt;H;i++){
  
             temp = Integer.toString(random.nextInt(100)+1);
          for(int b=0;b&lt;A-1;b++){
              temp += " " + Integer.toString(random.nextInt(100)+1);
          }
  
             planets = /*input.nextLine()*//*Integer.toString(random.nextInt(100)+1) + " " + Integer.toString(random.nextInt(100)+1) + " " + Integer.toString(random.nextInt(100)+1)*/temp;
  
             //planets = input.nextLine();
             index1 = 0;
             int j =0;
             while((index2 = planets.indexOf(' ',index1))!=-1){
                 distance[i][j] = Integer.valueOf(planets.substring(index1, index2));
                 index1= index2+1;
                 j++;
             }
             distance[i][j] = Integer.valueOf(planets.substring(index1));
  
         }
          if(H&gt;=A){
  
         int[][] minimumYearsToDefeat = new int[H][A];
         for(int i=0;i&lt;H;i++){
             for(int j=0;j&lt;A;j++){
                 double x,y,z;
                 y = aliasPlanets.elementAt(j*2) + humanPlanets.elementAt(i*2+1)*distance[i][j]-humanPlanets.elementAt(i*2);
                 z = humanPlanets.elementAt(i*2+1) - aliasPlanets.elementAt(j*2+1);
                 if(z==0){
                     if(y&lt;=0)
                         x = distance[i][j];
                     else
                         x = Integer.MAX_VALUE;
                 }
                 else{
                 x = y/z;
                 }
                 if(x==0){
                     x=1;
                 }
                 else if(x&lt;0){
                     x= Integer.MAX_VALUE;
                 }
                 minimumYearsToDefeat[i][j] = (int)Math.ceil(x);
             }
         }
  
         for(int i=0;i&lt;H;i++){
             for(int j=0;j&lt;A;j++)
                 System.out.print(minimumYearsToDefeat[i][j]+" ");
             System.out.println();
         }
  
         int[] mins = new int[A];//meqdar dehi ba big integer
         for(int i=0;i&lt;A;i++){
             mins[i] = Integer.MAX_VALUE;
         }
         int[] minsWith = new int[A];//meqdar dehi ba -1
         for(int i=0;i&lt;A;i++){
             minsWith[i] = -1;
         }
  
         for(int i=0;i&lt;A;i++){
             for(int j=0;j&lt;H;j++){
                 if(minimumYearsToDefeat[j][i]&lt;mins[i]){
                     mins[i] = minimumYearsToDefeat[j][i];
                     minsWith[i] = j;
                 }
             }
  
  
             for(int p=0;p&lt;A;p++){
                 if(minsWith[i]==minsWith[p]&amp;&amp;p!=i&amp;&amp;mins[i]!=Integer.MAX_VALUE){
                     correctingConflict(minimumYearsToDefeat, mins, minsWith, i, p, new Vector&lt;Integer&gt;());
                 }
             }
  
  
         }
         int result = 0;
         for(int i=0;i&lt;A;i++){
             if (mins[i]&gt;result)
                 result = mins[i];
  
         }
         if(result==Integer.MAX_VALUE){
             System.out.println("IMPOSSIBLE");
         }
         else{
             System.out.println(result);
         }
      }
          else{
              System.out.println("IMPOSSIBLE");
          }
      }
  }
  
  public static void correctingConflict(int[][] W, int[] mins, int[] minsWith, int i, int p, Vector&lt;Integer&gt; vector){
      /*for(int v=0;v&lt;A;v++){
      System.out.print(minsWith[v]+" ");
      }
      System.out.println();
      for(int v=0;v&lt;vector.size();v++){
      System.out.print(vector.elementAt(v)+" ");
      }
      System.out.println();*/
      int nextMin1 = Integer.MAX_VALUE;
      int nextMin2 = Integer.MAX_VALUE;
      int nextMinWith1 = minsWith[i];
      int nextMinWith2 = minsWith[p];
  
      for(int q=0;q&lt;H;q++){
          if(W[q][i]&lt;nextMin1 &amp;&amp; W[q][i]&gt;=mins[i] &amp;&amp; q!=minsWith[i] &amp;&amp; !vector.contains(q)){
              nextMin1 = W[q][i];
              nextMinWith1 = q;
          }
  
      }
      for(int q=0;q&lt;H;q++){
          if(W[q][p]&lt;nextMin2 &amp;&amp; W[q][p]&gt;=mins[p] &amp;&amp; q!=minsWith[p] &amp;&amp; !vector.contains(q)){
              nextMin2 = W[q][p];
              nextMinWith2 = q;
          }
      }
  
      if(nextMin1&lt;=nextMin2){
          if (nextMin1==mins[i]) {
              vector.addElement(minsWith[p]);
          } else {
              vector.removeAllElements();
          }
          mins[i] = nextMin1;
          minsWith[i] = nextMinWith1;
  
          //conflict checking
          for(int s=0;s&lt;A;s++){
                 if(minsWith[i]==minsWith[s]&amp;&amp;s!=i&amp;&amp;mins[i]!=Integer.MAX_VALUE){
                     correctingConflict(W, mins, minsWith, i, s, vector);
                     return;
                 }
          }
  
      }
      else if(nextMin2&lt;nextMin1){
          if (nextMin2==mins[p]) {
              vector.removeAllElements();
              vector.addElement(minsWith[p]);
          } else {
              vector.removeAllElements();
          }
          mins[p] = nextMin2;
          minsWith[p] = nextMinWith2;
  
          //conflict checking
          for(int s=0;s&lt;A;s++){
                 if(minsWith[p]==minsWith[s]&amp;&amp;s!=p&amp;&amp;mins[p]!=Integer.MAX_VALUE){
                     correctingConflict(W, mins, minsWith, p, s, vector);
                     return;
                 }
          }
      }
  
  
  
  
  }
  
  }
  </code></pre>