result->datapredecode_area =
    predecode_area (rows_datasubarray, parameters->num_readwrite_ports,
		    parameters->num_read_ports, parameters->num_write_ports);
  result->datacolmuxpredecode_area =
    predecode_area (colns_datasubarray, parameters->num_readwrite_ports,
		    parameters->num_read_ports, parameters->num_write_ports);
  result->datacolmuxpostdecode_area =
    postdecode_area (colns_datasubarray, parameters->num_readwrite_ports,
		     parameters->num_read_ports, parameters->num_write_ports);
  result->datawritesig_area =
    muxdrvsig (parameters->data_associativity, parameters->block_size, b0);

 //if-else on pure_sram_flag added by Shyam so that tag array area not calculated in
  //pure SRAM mode
  if(!pure_sram_flag)  {

	  result->tagarray_area =
		tagarray (baddr, parameters->cache_size, parameters->block_size,
			  parameters->tag_associativity, Ntbl, Ntwl, Ntspd, NSubbanks,
			  parameters->num_readwrite_ports, parameters->num_read_ports,
			  parameters->num_write_ports,
			  parameters->num_single_ended_read_ports,
			  parameters->fudgefactor);
	  result->tagpredecode_area =
		predecode_area (rows_tagsubarray, parameters->num_readwrite_ports,
				parameters->num_read_ports, parameters->num_write_ports);
	  result->tagcolmuxpredecode_area =
		predecode_area (colns_tagsubarray, parameters->num_readwrite_ports,
				parameters->num_read_ports, parameters->num_write_ports);
	  result->tagcolmuxpostdecode_area =
		postdecode_area (colns_tagsubarray, parameters->num_readwrite_ports,
				 parameters->num_read_ports, parameters->num_write_ports);
	  result->tagoutdrvdecode_area =
		muxdriverdecode (parameters->block_size, b0,
				 parameters->num_readwrite_ports,
				 parameters->num_read_ports, parameters->num_write_ports);
	  result->tagoutdrvsig_area =
		muxdrvsig (parameters->tag_associativity, parameters->block_size, b0);
  }
  else{
		result->tagarray_area.height = 0;
		result->tagarray_area.width = 0;
		result->tagarray_area.scaled_area = 0;
		result->tagpredecode_area.height = 0;
		result->tagpredecode_area.width = 0;
		result->tagpredecode_area.scaled_area = 0;
		result->tagcolmuxpredecode_area.height = 0;
		result->tagcolmuxpredecode_area.width = 0;
		result->tagcolmuxpredecode_area.scaled_area = 0;
		result->tagcolmuxpostdecode_area.height = 0;
		result->tagcolmuxpostdecode_area.width = 0;
		result->tagcolmuxpostdecode_area.scaled_area = 0;
		result->tagoutdrvdecode_area.height = 0;
		result->tagoutdrvdecode_area.width = 0;
		result->tagoutdrvdecode_area.scaled_area = 0;
		result->tagoutdrvsig_area.height = 0;
		result->tagoutdrvsig_area.width = 0;
		result->tagoutdrvsig_area.scaled_area = 0;

  }

  /*result->totalarea =
    calculate_area (result->dataarray_area,
		    parameters->fudgefactor) +
    calculate_area (result->datapredecode_area,
		    parameters->fudgefactor) +
    calculate_area (result->datacolmuxpredecode_area,
		    parameters->fudgefactor) +
    calculate_area (result->datacolmuxpostdecode_area,
		    parameters->fudgefactor) +
    (parameters->num_readwrite_ports +
     parameters->num_write_ports) * calculate_area (result->datawritesig_area,
						    parameters->fudgefactor) +
    calculate_area (result->tagarray_area,
		    parameters->fudgefactor) +
    calculate_area (result->tagpredecode_area,
		    parameters->fudgefactor) +
    calculate_area (result->tagcolmuxpredecode_area,
		    parameters->fudgefactor) +
    calculate_area (result->tagcolmuxpostdecode_area,
		    parameters->fudgefactor) +
    calculate_area (result->tagoutdrvdecode_area,
		    parameters->fudgefactor) +
    (parameters->num_readwrite_ports +
     parameters->num_read_ports) * calculate_area (result->tagoutdrvsig_area,
						   parameters->fudgefactor);*/


  result->totalarea = result->dataarray_area.height * result->dataarray_area.width + 
	  result->datapredecode_area.height * result->datapredecode_area.width  + 
	  result->datacolmuxpredecode_area.height * result->datacolmuxpredecode_area.width + 
	  result->datacolmuxpostdecode_area.height * result->datacolmuxpostdecode_area.width +
    (parameters->num_readwrite_ports + parameters->num_write_ports) * result->datawritesig_area.height * result->datawritesig_area.width + 
	result->tagarray_area.height * result->tagarray_area.width + 
	result->tagpredecode_area.height * result->tagpredecode_area.width + 
	result->tagcolmuxpredecode_area.height * result->tagcolmuxpredecode_area.width +
    result->tagcolmuxpostdecode_area.height * result->tagcolmuxpostdecode_area.width + 
	result->tagoutdrvdecode_area.height * result->tagoutdrvdecode_area.width +
    (parameters->num_readwrite_ports +  parameters->num_read_ports) * result->tagoutdrvsig_area.height * result->tagoutdrvsig_area.width;

}

area_type
fadecode_row (int C,int B,int Ndbl,int RWP,int ERP,int EWP)	/*returns area of post decode */
{
  int numstack;
  double decodeNORwidth, firstinv;
  area_type decinv, worddriveinv, postdecodearea;

  //v4.1: using integer casting below 
  //numstack =
    //ceil ((1.0 / 3.0) * logtwo_area ((double) ((double) C / (double) (B))));
  numstack =
    (int) (ceil ((1.0 / 3.0) * logtwo_area ((double) ((double) C / (double) (B)))));
  if (numstack == 0)
    numstack = 1;
  if (numstack > 6)
    numstack = 6;
  switch (numstack)
    {
    case 1:
      decodeNORwidth = WidthNOR1;
      break;
    case 2:
      decodeNORwidth = WidthNOR2;
      break;
    case 3:
      decodeNORwidth = WidthNOR3;
      break;
    case 4:
      decodeNORwidth = WidthNOR4;
      break;
    case 5:
      decodeNORwidth = WidthNOR5;
      break;
    case 6:
      decodeNORwidth = WidthNOR6;
      break;
    default:
      printf ("error:numstack=%d\n", numstack);
      printf ("Cacti does not support a series stack of %d transistors !\n",
	      numstack);
      exit (0);
      break;

    }
  decinv = inverter_area (Wdecinvp, Wdecinvn);
  worddriveinv = inverter_area (Wdecinvp, Wdecinvn);
  switch (numstack)
    {
    case 1:
      firstinv = decinv.height;
      break;
    case 2:
      firstinv = decinv.height;
      break;
    case 3:
      firstinv = decinv.height;
      break;
    case 4:
      firstinv = decNandWidth;
      break;
    case 5:
      firstinv = decNandWidth;
      break;
    case 6:
      firstinv = decNandWidth;
      break;
    default:
      printf ("error:numstack=%d\n", numstack);
      printf ("Cacti does not support a series stack of %d transistors !\n",
	      numstack);
      exit (0);
      break;

    }

  /*
  was : postdecodearea.height = BitHeight16x2;
  */
  postdecodearea.height = 2*BitHeight1x1;
  postdecodearea.width =
    (decodeNORwidth + firstinv + worddriveinv.height) * (RWP + EWP);
  return (postdecodearea);
}

area_type
fasubarray (int baddr,int C,int B,int Ndbl,int RWP,int ERP,int EWP,int NSER,double techscaling_factor)	/* returns area of subarray */
{
  area_type FAarea, fadecoderow, faramcell;
  int noof_rowsdata, noof_colnsdata;
  int Tagbits, HTagbits;
  double precharge, widthoverhead, heightoverhead;

  noof_rowsdata = (C / (B * Ndbl));
  noof_colnsdata = (8 * B);
  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
  //the final int value is the correct one 
  //Tagbits = baddr - logtwo_area ((double) (B)) + 2;
  Tagbits = (int) (baddr - logtwo_area ((double) (B)) + 2 + EPSILON);
  
  //v4.1: using integer casting below 
  //HTagbits = ceil ((double) (Tagbits) / 2.0);
  HTagbits = (int)(ceil ((double) (Tagbits) / 2.0));
  precharge =
    Wbitpreequ + 2 * Wbitdropv + Wwrite + 2 * (2 * Widthcontact + 1 / FUDGEFACTOR) +
    3 * Widthptondiff;

  if ((RWP == 1) && (ERP == 0) && (EWP == 0))
    {
      heightoverhead = 0;
      widthoverhead = 0;
    }
  else
    {
      if ((RWP == 1) && (ERP == 1) && (EWP == 0))
	{
	  widthoverhead = FAWidthIncrPer_first_r_port;
	  heightoverhead = FAHeightIncrPer_first_r_port;
	}
      else
	{
	  if ((RWP == 1) && (ERP == 0) && (EWP == 1))
	    {
	      widthoverhead = FAWidthIncrPer_first_rw_or_w_port;
	      heightoverhead = FAHeightIncrPer_first_rw_or_w_port;
	    }
	  else
	    {
	      if (RWP + EWP >= 2)
		{
		  widthoverhead =
		    FAWidthIncrPer_first_rw_or_w_port + (RWP + EWP -
							 2) *
		    FAWidthIncrPer_later_rw_or_w_port +
		    ERP * FAWidthIncrPer_later_r_port;
		  heightoverhead =
		    FAHeightIncrPer_first_rw_or_w_port + (RWP + EWP -
							  2) *
		    FAHeightIncrPer_later_rw_or_w_port +
		    ERP * FAHeightIncrPer_later_r_port;}
	      else
		{
		  if ((RWP == 0) && (EWP == 0))
		    {
		      widthoverhead =
			FAWidthIncrPer_first_r_port + (ERP -
						       1) *
			FAWidthIncrPer_later_r_port;
		      heightoverhead =
			FAHeightIncrPer_first_r_port + (ERP -
							1) *
			FAHeightIncrPer_later_r_port;;}
		  else
		    {
		      if ((RWP == 0) && (EWP == 1))
			{
			  widthoverhead = ERP * FAWidthIncrPer_later_r_port;
			  heightoverhead = ERP * FAHeightIncrPer_later_r_port;
			}
		      else
			{
			  if ((RWP == 1) && (EWP == 0))
			    {
			      widthoverhead =
				ERP * FAWidthIncrPer_later_r_port;
			      heightoverhead =
				ERP * FAHeightIncrPer_later_r_port;}
			}
		    }
		}
	    }
	}
    }

  faramcell.height =
    ceil ((double) (noof_rowsdata) / 16.0) * stitch_ramv + (CAM2x2Height_1p +
							    2 *
							    heightoverhead) *
    ceil ((double) (noof_rowsdata) / 2.0);

  /*
  was: faramcell.width=(ceil((double)(noof_colnsdata)/16.0))*(BitWidth16x2+16*(Widthtrack*2*(RWP+(ERP-NSER)+EWP-1)+Widthtrack*NSER))+2*(HTagbits*((CAM2x2Width_1p+2*widthoverhead)-Widthcontact))+(BitWidth+Widthtrack*2*(RWP+ERP+EWP-1))+(FArowNANDWidth+FArowNOR_INVWidth)*(RWP+ERP+EWP);
  */
  faramcell.width=noof_colnsdata*(BitWidth1x1+(Widthtrack*2*(RWP+(ERP-NSER)+EWP-1)+Widthtrack*NSER))+2*(HTagbits*((CAM2x2Width_1p+2*widthoverhead)-Widthcontact))+(BitWidth+Widthtrack*2*(RWP+ERP+EWP-1))+(FArowNANDWidth+FArowNOR_INVWidth)*(RWP+ERP+EWP);

  FAarea.height =
    faramcell.height + precharge * (RWP + EWP) + SenseampHeight * (RWP +
								   ERP) +
    DatainvHeight * (RWP + EWP) + FAOutdriveHeight * (RWP + ERP);
  FAarea.width = faramcell.width;

  fadecoderow = fadecode_row (C, B, Ndbl, RWP, ERP, EWP);
  FAarea.width = FAarea.width + fadecoderow.width;

  //area_all_dataramcells =
    //Ndbl * calculate_area (faramcell, techscaling_factor) * CONVERT_TO_MMSQUARE;
  //faarea_all_subarrays =
    //Ndbl * calculate_area (FAarea, techscaling_factor) * CONVERT_TO_MMSQUARE;
  area_all_dataramcells = Ndbl * faramcell.height * faramcell.width * CONVERT_TO_MMSQUARE;
  faarea_all_subarrays = Ndbl * FAarea.height * FAarea.width * CONVERT_TO_MMSQUARE;
  return (FAarea);
}

area_type
faarea (int baddr,int b0,int C,int B,int Ndbl,int RWP,int ERP,int EWP,int NSER,double techscaling_factor)
{
  area_type fasubarray_area, fa_area;
  int Tagbits, blocksel, N3to8;
  double fixed_tracks, predecode, base_height, base_width;
  area_type temp;
  double temp_aspect;

  int blocks, htree, htree_half, i, iter;
  double inter_height, inter_width, total_height, total_width;

  
  //v4.1: using integer casting below 
  //N3to8 =
    //ceil ((1.0 / 3.0) * logtwo_area ((double) ((double) C / (double) (B))));
 N3to8 =
    (int) (ceil ((1.0 / 3.0) * logtwo_area ((double) ((double) C / (double) (B)))));
  if (N3to8 == 0)
    {
      N3to8 = 1;
    }

  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
  //the final int value is the correct one 
  Tagbits =  (int)(baddr - logtwo_area ((double) (B)) + 2 + EPSILON);
  fasubarray_area =
    fasubarray (baddr, C, B, Ndbl, RWP, ERP, EWP, NSER, techscaling_factor);
  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
  //the final int value is the correct one 
  //blocksel = MAX (logtwo_area ((double) (B)), (8 * B) / b0);
  blocksel = MAX ((int)(logtwo_area ((double) (B)) + EPSILON), (8 * B) / b0);
  blocksel =
    (blocksel >
     tracks_outdrvfanand_p) ? (blocksel - tracks_outdrvfanand_p) : 0;

  fixed_tracks =
    Widthtrack * (1 * (RWP + EWP) + b0 * (RWP + ERP + EWP) +
		  Tagbits * (RWP + ERP + EWP) + blocksel * (RWP + ERP + EWP));
  predecode = Widthtrack * (N3to8 * 8) * (RWP + EWP);

  if (Ndbl == 1)
    {
      total_height = fasubarray_area.height + fixed_tracks;
      total_width = fasubarray_area.width + predecode;
    }
  if (Ndbl == 2)
    {
      total_height = 2 * fasubarray_area.height + fixed_tracks;
      total_width = fasubarray_area.width + predecode;
    }
  if (Ndbl == 4)
    {
      total_height = 2 * fasubarray_area.height + fixed_tracks + predecode;
      total_width = 2 * fasubarray_area.width + predecode;
    }
  if (Ndbl > 4)
    {
      blocks = Ndbl / 4;
	  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
      //the final int value is the correct one 
      //htree = (int) (logtwo_area ((double) (blocks)));
	  htree = (int) (logtwo_area ((double) (blocks)) + EPSILON);
      base_height = 2 * fasubarray_area.height + fixed_tracks + predecode;
      base_width = 2 * fasubarray_area.width + predecode;

      inter_height = base_height;
      inter_width = base_width;

      if (htree % 2 == 0)
	{
	  iter = htree / 2;
	}

      if (htree % 2 == 0)
	{
	  for (i = 1; i <= iter; i++)
	    {