struct defs

typedefs

global vars

void dealwithargs(int argc, char *argv[]);
void new_cputime(int i);
void compute_nodes(node_t_st37 *nodelist);
void print_graph(graph_t_st41 graph);
int main(int argc, char *argv[]);
node_t_st43 **make_table(int size);
void fill_table(node_t_st43 **table, int size);
void make_neighbors(node_t_st43 *nodelist, node_t_st43 **table, int tablesz, 
                    int degree, double percent_local);
void update_from_coeffs(node_t_st43 *nodelist);
void fill_from_fields(node_t_st43 *nodelist, int degree);
graph_t_st44 initialize_graph();
void init_random(int myid);
int gen_number(int range);
int gen_signed_number(int range);
double gen_uniform_double();
int check_percent(int percent);

void dealwithargs(
int argc, 
char *argv[])
{
  local vars

  if ((argc1 > 1))
  {
    /** n_nodes = atoi(argv[1]) **/
    temp_141 = argv1[1];
    n_nodes2 = atoi(temp_141);
  }
  else
  {
    n_nodes3 = 10;
  }
  if ((argc1 > 2))
  {
    /** d_nodes = atoi(argv[2]) **/
    temp_151 = argv1[2];
    d_nodes2 = atoi(temp_151);
  }
  else
  {
    d_nodes3 = 3;
  }
  if ((argc1 > 3))
  {
    /** local_p = atoi(argv[3]) **/
    temp_161 = argv1[3];
    local_p2 = atoi(temp_161);
  }
  else
  {
    local_p3 = 75;
  }
}

void new_cputime(
int i)
{
  local vars

  temp_17 = (&usage);
  getrusage(0, temp_17);
  temp_19 = usage.ru_utime.tv_sec;
  temp_20 = (double ) temp_19;
  temp_18 = (temp_20 * 1.00000000000000e+06);
  temp_21 = usage.ru_utime.tv_usec;
  temp_22 = (double ) temp_21;
  time = (temp_18 + temp_22);
  if ((i == 1))
  {
    t1_st35 = time;
  }
  else
  {
    /** printf("Total Execution Time in ms %10.3f\n", ((time - t1_st35) / 1.00000000000000e+03)) **/
    temp_23 = "Total Execution Time in ms %10.3f\n";
    temp_25 = (time - t1_st35);
    temp_24 = (temp_25 / 1.00000000000000e+03);
    printf(temp_23, temp_24);
  }
}

void compute_nodes(
node_t_st37 *nodelist)
{
  local vars

  for (  ; (nodelist2 != 0) ; 
        nodelist3 = (*nodelist2).next )
  {
    i2 = 0;
    for ( temp_262 = (*nodelist2).from_count ; 
         (i3 < temp_263) ; 
          temp_264 = (*nodelist2).from_count )
    {
      temp_273 = (*nodelist2).from_nodes;
      other_node3 = temp_273[i3];
      temp_283 = (*nodelist2).coeffs;
      coeff3 = temp_283[i3];
      value3 = (*other_node3).value;
      temp_293 = nodelist2;
      temp_303 = (*temp_293).value;
      temp_313 = (coeff3 * value3);
      (*temp_293).value = (temp_303 - temp_313);
      i4 = (i3 + 1);
    }
  }
}

void print_graph(
graph_t_st41 graph)
{
  local vars

  for ( cur_node1 = graph1.e_nodes ; (cur_node2 != 0) ; cur_node3 = (*cur_node2).next )
  {
    temp_322 = "E: value %f, from_count %d\n";
    temp_332 = (*cur_node2).value;
    temp_342 = (*cur_node2).from_count;
    printf(temp_322, temp_332, temp_342);
  }
  for ( cur_node5 = graph1.h_nodes ; (cur_node6 != 0) ; cur_node7 = (*cur_node6).next )
  {
    temp_352 = "H: value %f, from_count %d\n";
    temp_362 = (*cur_node6).value;
    temp_372 = (*cur_node6).from_count;
    printf(temp_352, temp_362, temp_372);
  }
}

int main(
int argc, 
char *argv[])
{
  local vars

  dealwithargs1(argc1, argv1);
  init_random2(2);
  graph2 = initialize_graph3();
  print_graph4(graph2);
  temp_381 = graph2.e_nodes;
  compute_nodes5(temp_381);
  temp_391 = graph2.h_nodes;
  compute_nodes6(temp_391);
  temp_401 = "Completed a computation phase\n";
  printf(temp_401);
  print_graph7(graph2);
}

node_t_st43 **make_table(
int size)
{
  local vars

  temp_421 = (unsigned int ) size1;
  temp_411 = (temp_421 * 4);
  temp_432 = malloc(temp_411);
  retval1 = (struct node_t **) temp_432;
  if ((retval1 == 0))
  {
    temp_441 = "Assertion failure\n";
    printf(temp_441);
    exit(-1);
  }
  return (retval1);
}

void fill_table(
node_t_st43 **table, 
int size)
{
  local vars

  temp_452 = malloc(32);
  prev_node1 = (struct node_t *) temp_452;
  table1[0] = prev_node1;
  (*prev_node1).value = gen_uniform_double1();
  (*prev_node1).from_count = 0;
  for ( i1 = 1 ; (i2 < size1) ; i3 = (i2 + 1) )
  {
    temp_463 = malloc(32);
    cur_node2 = (struct node_t *) temp_463;
    (*cur_node2).value = gen_uniform_double2();
    (*cur_node2).from_count = 0;
    table1[i2] = cur_node2;
    (*prev_node2).next = cur_node2;
    prev_node3 = cur_node2;
  }
  (*cur_node3).next = 0;
}

void make_neighbors(
node_t_st43 *nodelist, 
node_t_st43 **table, 
int tablesz, 
int degree, 
double percent_local)
{
  local vars

  for ( cur_node1 = nodelist1 ; (cur_node2 != 0) ; cur_node3 = (*cur_node2).next )
  {
    temp_482 = (unsigned int ) degree1;
    temp_472 = (temp_482 * 4);
    temp_493 = malloc(temp_472);
    (*cur_node2).to_nodes = (struct node_t **) temp_493;
    for ( j2 = 0 ; (j3 < degree1) ; j4 = (j3 + 1) )
    {
      do 
      {
        temp_505 = gen_number1(tablesz1);
        other_node4 = table1[temp_505];
        for ( k4 = 0 ; (k5 < j3) ; k6 = (k5 + 1) )
        {
          /** (other_node == (*cur_node).to_nodes[k]) **/
          temp_525 = (*cur_node2).to_nodes;
          temp_515 = temp_525[k5];
          if ((other_node4 == temp_515))
          {
            break; 
          }
        }
      }
      while ( (k7 < j3) );
      temp_533 = (*cur_node2).to_nodes;
      temp_533[j3] = other_node4;
      temp_543 = (*other_node4).from_count;
      (*other_node4).from_count = (temp_543 + 1);
    }
  }
}

void update_from_coeffs(
node_t_st43 *nodelist)
{
  local vars

  for ( cur_node1 = nodelist1 ; (cur_node2 != 0) ; cur_node3 = (*cur_node2).next )
  {
    from_count2 = (*cur_node2).from_count;
    temp_562 = (unsigned int ) from_count2;
    temp_552 = (temp_562 * 4);
    temp_573 = malloc(temp_552);
    (*cur_node2).from_nodes = (struct node_t **) temp_573;
    temp_592 = (unsigned int ) from_count2;
    temp_582 = (temp_592 * 8);
    temp_603 = malloc(temp_582);
    (*cur_node2).coeffs = (double *) temp_603;
    (*cur_node2).from_length = 0;
    for ( k2 = 0 ; (k3 < from_count2) ; k4 = (k3 + 1) )
    {
      /** (*cur_node).coeffs[k] = gen_uniform_double() **/
      temp_613 = (*cur_node2).coeffs;
      temp_613[k3] = gen_uniform_double1();
    }
  }
}

void fill_from_fields(
node_t_st43 *nodelist, 
int degree)
{
  local vars

  for ( cur_node1 = nodelist1 ; (cur_node2 != 0) ; cur_node3 = (*cur_node2).next )
  {
    for ( j2 = 0 ; (j3 < degree1) ; j4 = (j3 + 1) )
    {
      temp_623 = (*cur_node2).to_nodes;
      other_node3 = temp_623[j3];
      count3 = (*other_node3).from_length;
      temp_633 = count3;
      count4 = (count3 + 1);
      temp_643 = (*other_node3).from_nodes;
      temp_643[temp_633] = cur_node2;
      (*other_node3).from_length = count4;
    }
  }
}

graph_t_st44 initialize_graph()
{
  local vars

  h_table2 = make_table1(n_nodes11);
  fill_table2(h_table2, n_nodes11);
  e_table2 = make_table3(n_nodes11);
  fill_table4(e_table2, n_nodes11);
  temp_651 = h_table2[0];
  temp_661 = (double ) local_p11;
  make_neighbors5(temp_651, e_table2, n_nodes11, d_nodes11, temp_661);
  temp_671 = e_table2[0];
  temp_681 = (double ) local_p11;
  make_neighbors6(temp_671, h_table2, n_nodes11, d_nodes11, temp_681);
  temp_691 = h_table2[0];
  update_from_coeffs7(temp_691);
  temp_701 = e_table2[0];
  update_from_coeffs8(temp_701);
  temp_711 = h_table2[0];
  fill_from_fields9(temp_711, d_nodes11);
  temp_721 = e_table2[0];
  fill_from_fields10(temp_721, d_nodes11);
  retval1.e_nodes = e_table2[0];
  retval1.h_nodes = h_table2[0];
  free11(h_table2);
  free12(e_table2);
  return (retval1);
}
extern int atoi();
extern long lrand48();

void init_random(
int myid)
{
  local vars

  temp_731 = (myid1 * 45);
  temp_741 = (long ) temp_731;
  srand48(temp_741);
}

int gen_number(
int range)
{
  local vars

  temp_762 = lrand48();
  temp_771 = (long ) range1;
  temp_751 = (temp_762 % temp_771);
  return (temp_751);
}

int gen_signed_number(
int range)
{
  local vars

  temp_78 = lrand48();
  temp_79 = (2 * range);
  temp_80 = (temp_79 - 1);
  temp_81 = (long ) temp_80;
  temp_82 = (temp_78 % temp_81);
  temp = (int ) temp_82;
  temp_84 = (temp - -1);
  temp_83 = (temp_84 - range);
  return (temp_83);
}

double gen_uniform_double()
{
  local vars

  temp_852 = drand48();
  return (temp_852);
}

int check_percent(
int percent)
{
  local vars

  temp_87 = drand48();
  temp_89 = (double ) percent;
  temp_88 = (temp_89 / 1.00000000000000e+02);
  temp_86 = (temp_87 < temp_88);
  return (temp_86);
}