#include <stdio.h>
#include <math.h>

#define  TRUE                1
#define  FALSE               0

float print_array(array)
float array[2][50];

{
  int i;

  for (i = 0; i <= 49; i++)
    printf(" %f %f \n", array[0][i], array[1][i]);
}

float distance(x1,y1,x2,y2)

float x1,y1,x2,y2;

{
  float dist;

  dist = sqrt (((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));

  return(dist);
}

float minimum(first,second)

float first, second;

{

  if(first < second) {
    printf("%f %f \n", first, second);
    return(first); }
  else
    return(second);
}

int initialize_array(airplane_positions)

float airplane_positions[2][50];

{
  int n;

  for(n=0; n <= 49; n++)
  {
    airplane_positions[0][n] = -100;
    airplane_positions[1][n] = -100;
  }

  return(TRUE);
}

float read_input_from_file(airplane_positions)

float airplane_positions[2][50];

{
  int n=0;
  
  while((airplane_positions[0][n] != EOF) && (n <= 49))
  {
    scanf("%f %f", &airplane_positions[0][n], &airplane_positions[1][n]);
    n++;
  }
  
  return(TRUE);
}

float iterate_minimum(airplane_positions)

float airplane_positions[2][50];

{
  int n=0, i=0;
  int placemarker = 0;
  float x_test_coordinate=0, y_test_coordinate=0;
  float current_minimum_distance = 99999;
  float x_coord = 0, y_coord = 0;
  float this_dist;

  while(placemarker <= 49)
  {
    x_test_coordinate = airplane_positions[0][placemarker];
    y_test_coordinate = airplane_positions[1][placemarker];
    airplane_positions[0][placemarker] = 99999;
    airplane_positions[1][placemarker] = 99999;

    for(i=0; i <= 49; i++)
    {
      if (airplane_positions[0][i] == -100) {
	i = 51; }
      else {
	
	x_coord = airplane_positions[0][i];
	y_coord = airplane_positions[1][i];
	this_dist = distance(x_test_coordinate,y_test_coordinate,x_coord,y_coord);

	if(this_dist == minimum(this_dist,current_minimum_distance))
	  current_minimum_distance = this_dist;
      }
    }

    airplane_positions[0][placemarker] = x_test_coordinate;
    airplane_positions[1][placemarker] = y_test_coordinate;

    placemarker++;
  }

  return(current_minimum_distance);
}


int find_length_of_original(airplane_positions)
    
float airplane_positions[2][50];
{
  int n = 0;

  while(n <= 49)
  {
    if (airplane_positions[0][n] != -100)
      n++;
    else
      return(n+1);
 }
  return(n+1);
}

int even (integer)

int integer;
{

  if ((integer / 2) == ((integer - 1) / 2)) {
    return (FALSE); }
  else
  {
    return (TRUE); }
}

float copy_into_new(array, airplane_positions, start_point, length)

float array[2][50];
float airplane_positions[2][50];
int start_point;
int length ;

{
  int i;

  for (i = start_point; i <= length; i++)
  {
    array[0][i] = airplane_positions[0][i];
    array[1][i] = airplane_positions[1][i];
  }

return (TRUE);
}

float minimum_across_the_line(airplane_positions, line_point_x, length, delta)

float airplane_positions[2][50];
float line_point_x;
int length;
float delta;
{

  int new_array[2][50];
  int i,j=0;
  float new_minimum;

  initialize_array(new_array);

  for(i=0; i <= length; i++)
  {
    if (abs(line_point_x - airplane_positions[0][i]) < delta)
    {
      printf("minus: %f \n",(line_point_x - airplane_positions[0][i]));
      new_array[0][j] = airplane_positions[0][i];
      new_array[1][j] = airplane_positions[1][i];
      j++;
    }
  }

  new_minimum = iterate_minimum(new_array);
  
  return(new_minimum);

}

float split_open_and_melt(airplane_positions, array_length)

float airplane_positions[2][50];
int array_length;

{
  float new_array_1[2][50];
  float new_array_2[2][50];
  float minimum1;
  float minimum2;
  float total_minimum;
  float line_minimum = 0.0;
  float line_point;

  if (array_length <= 3) {
    return (iterate_minimum(airplane_positions)); }
  else {
    initialize_array(new_array_1);
    initialize_array(new_array_2);
 
    if (even (array_length))
    {
      line_point = airplane_positions[0][((array_length / 2) - 1)];

      copy_into_new(new_array_1, airplane_positions, 0, (array_length / 2));
      copy_into_new(new_array_2, airplane_positions, (array_length / 2), (array_length / 2));

      minimum1 = split_open_and_melt(new_array_1, (array_length / 2));
      minimum2 = split_open_and_melt(new_array_2, (array_length / 2));

      total_minimum = minimum(minimum1, minimum2);
      line_minimum = minimum_across_the_line(airplane_positions, line_point, array_length, total_minimum);
      printf("AAAAAAAAAAAARRRRRRRRRRRGGGGGGGGGGGHHHHHHHHH");
      total_minimum = minimum(total_minimum,line_minimum);
      return(total_minimum);
    }

    else
    {
      line_point = airplane_positions[0][(((array_length - 1) / 2) + 1)];

      copy_into_new(new_array_1, airplane_positions, 0, ((array_length - 1) / 2));
      copy_into_new(new_array_2, airplane_positions, ((array_length - 1) / 2), (((array_length - 1) / 2) + 2));

      minimum1 = split_open_and_melt(new_array_1, ((array_length - 1) / 2));
      minimum2 = split_open_and_melt(new_array_2, ((array_length - 1) / 2));

      total_minimum = minimum(minimum1, minimum2);

      line_minimum = minimum_across_the_line(airplane_positions, line_point, array_length, total_minimum);
      printf("AAAAAAAAAAAARRRRRRRRRRRGGGGGGGGGGGHHHHHHHHH");
      total_minimum = minimum(total_minimum, line_minimum);
      return(total_minimum);
    }
  }
}

main()
{

  float airplane_positions[2][50];
  float total_minimum;
  int array_length;
  
  initialize_array(airplane_positions);

/* Take the file and put data in the array */

  read_input_from_file(airplane_positions);

  array_length = find_length_of_original(airplane_positions);

  total_minimum = split_open_and_melt(airplane_positions, array_length);

  printf("The minimum distance between any two points is %.2f \n", total_minimum);

}