expr_tree));
integer_zero_node));
ffecom_expr_intrinsic_ (ffebld expr, tree dest_tree,			ffebld dest, bool *dest_used){  tree expr_tree;  tree saved_expr1;		/* For those who need it. */  tree saved_expr2;		/* For those who need it. */  ffeinfoBasictype bt;  ffeinfoKindtype kt;  tree tree_type;  tree arg1_type;  tree real_type;		/* REAL type corresponding to COMPLEX. */  tree tempvar;  ffebld list = ffebld_right (expr);	/* List of (some) args. */  ffebld arg1;			/* For handy reference. */  ffebld arg2;  ffebld arg3;  ffecomGfrt ix;  assert (ffebld_op (ffebld_left (expr)) == FFEBLD_opSYMTER);  if (dest_used != NULL)    *dest_used = FALSE;  bt = ffeinfo_basictype (ffebld_info (expr));  kt = ffeinfo_kindtype (ffebld_info (expr));  tree_type = ffecom_tree_type[bt][kt];  if (list != NULL)    {      arg1 = ffebld_head (list);      if (arg1 != NULL && ffebld_op (arg1) == FFEBLD_opANY)	return error_mark_node;      if ((list = ffebld_trail (list)) != NULL)	{	  arg2 = ffebld_head (list);	  if (arg2 != NULL && ffebld_op (arg2) == FFEBLD_opANY)	    return error_mark_node;	  if ((list = ffebld_trail (list)) != NULL)	    {	      arg3 = ffebld_head (list);	      if (arg3 != NULL && ffebld_op (arg3) == FFEBLD_opANY)		return error_mark_node;	    }	  else	    arg3 = NULL;	}      else	arg2 = arg3 = NULL;    }  else    arg1 = arg2 = arg3 = NULL;  /* <list> ends up at the opITEM of the 3rd arg, or NULL if there are < 3     args.  This is used by the MAX/MIN expansions. */  if (arg1 != NULL)    arg1_type = ffecom_tree_type      [ffeinfo_basictype (ffebld_info (arg1))]      [ffeinfo_kindtype (ffebld_info (arg1))];  else    arg1_type = NULL_TREE;	/* Really not needed, but might catch bugs				   here. */  /* There are several ways for each of the cases in the following switch     statements to exit (from simplest to use to most complicated):     break;  (when expr_tree == NULL)     A standard call is made to the specific intrinsic just as if it had been     passed in as a dummy procedure and called as any old procedure.  This     method can produce slower code but in some cases its the easiest way for     now.     goto library;     ix contains the gfrt index of a library function to call, passing the     argument(s) by value rather than by reference.     return expr_tree;     The expr_tree has been completely set up and is ready to be returned     as is.  No further actions are taken.  Use this when the tree is not     in the simple form for one of the arity_n labels.	 */  /* For info on how the switch statement cases were written, see the files     enclosed in comments below the switch statement. */  switch (ffeintrin_codegen_imp	  (ffebld_symter_implementation (ffebld_left (expr))))    {    case FFEINTRIN_impABS:	/* Plus impCABS, impCDABS, impDABS, impIABS. */      if (ffeinfo_basictype (ffebld_info (arg1))	  == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCABS;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDABS;	  else	    {	      assert ("bad ABS COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  goto library;		/* :::::::::::::::::::: */	}      return ffecom_1 (ABS_EXPR, tree_type,		       convert (tree_type, ffecom_expr (arg1)));    case FFEINTRIN_impACOS:	/* Plus impDACOS. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ACOS;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ACOS;      else	{	  assert ("bad ACOS kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impAIMAG:	/* Plus impDIMAG. */      return	convert (tree_type,		 ffecom_1 (IMAGPART_EXPR, TREE_TYPE (arg1_type),			   ffecom_expr (arg1)));    case FFEINTRIN_impAINT:	/* Plus impDINT. */#if 0				/* ~~ someday implement FIX_TRUNC_EXPR				   yielding same type as arg */      return ffecom_1 (FIX_TRUNC_EXPR, tree_type, ffecom_expr (arg1));#else /* in the meantime, must use floor to avoid range problems with ints */      /* r__1 = r1 >= 0 ? floor(r1) : -floor(-r1); */      saved_expr1 = ffecom_save_tree (ffecom_expr (arg1));      return	convert (tree_type,		 ffecom_3 (COND_EXPR, double_type_node,			   ffecom_truth_value			   (ffecom_2 (GE_EXPR, integer_type_node,				      saved_expr1,				      convert (arg1_type,					       ffecom_float_zero_))),			   ffecom_call_gfrt (FFECOM_gfrtL_FLOOR,					     build_tree_list (NULL_TREE,						  convert (double_type_node,							   saved_expr1))),			   ffecom_1 (NEGATE_EXPR, double_type_node,				     ffecom_call_gfrt (FFECOM_gfrtL_FLOOR,						 build_tree_list (NULL_TREE,						  convert (double_type_node,						      ffecom_1 (NEGATE_EXPR,								arg1_type,								saved_expr1))))				     ))		 );#endif    case FFEINTRIN_impANINT:	/* Plus impDNINT. */#if 0				/* This way of doing it won't handle real				   numbers of large magnitudes. */      saved_expr1 = ffecom_save_tree (ffecom_expr (arg1));      expr_tree = convert (tree_type,			   convert (integer_type_node,				    ffecom_3 (COND_EXPR, tree_type,					      ffecom_truth_value					      (ffecom_2 (GE_EXPR,							 integer_type_node,							 saved_expr1,						       ffecom_float_zero_)),					      ffecom_2 (PLUS_EXPR,							tree_type,							saved_expr1,							ffecom_float_half_),					      ffecom_2 (MINUS_EXPR,							tree_type,							saved_expr1,						     ffecom_float_half_))));      return expr_tree;#else /* So we instead call floor. */      /* r__1 = r1 >= 0 ? floor(r1 + .5) : -floor(.5 - r1) */      saved_expr1 = ffecom_save_tree (ffecom_expr (arg1));      return	convert (tree_type,		 ffecom_3 (COND_EXPR, double_type_node,			   ffecom_truth_value			   (ffecom_2 (GE_EXPR, integer_type_node,				      saved_expr1,				      convert (arg1_type,					       ffecom_float_zero_))),			   ffecom_call_gfrt (FFECOM_gfrtL_FLOOR,					     build_tree_list (NULL_TREE,						  convert (double_type_node,							   ffecom_2 (PLUS_EXPR,								     arg1_type,								     saved_expr1,								     convert (arg1_type,									      ffecom_float_half_))))),			   ffecom_1 (NEGATE_EXPR, double_type_node,				     ffecom_call_gfrt (FFECOM_gfrtL_FLOOR,						       build_tree_list (NULL_TREE,									convert (double_type_node,										 ffecom_2 (MINUS_EXPR,											   arg1_type,											   convert (arg1_type,												    ffecom_float_half_),											   saved_expr1)))))			   )		 );#endif    case FFEINTRIN_impASIN:	/* Plus impDASIN. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ASIN;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ASIN;      else	{	  assert ("bad ASIN kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impATAN:	/* Plus impDATAN. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ATAN;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ATAN;      else	{	  assert ("bad ATAN kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impATAN2:	/* Plus impDATAN2. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ATAN2;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ATAN2;      else	{	  assert ("bad ATAN2 kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impCHAR:    case FFEINTRIN_impACHAR:      assert (ffecom_pending_calls_ != 0);      tempvar = ffecom_push_tempvar (char_type_node,				     1, -1, TRUE);      {	tree tmv = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (tempvar)));	expr_tree = ffecom_modify (tmv,				   ffecom_2 (ARRAY_REF, tmv, tempvar,					     integer_one_node),				   convert (tmv, ffecom_expr (arg1)));      }      expr_tree = ffecom_2 (COMPOUND_EXPR, TREE_TYPE (tempvar),			    expr_tree,			    tempvar);      expr_tree = ffecom_1 (ADDR_EXPR,			    build_pointer_type (TREE_TYPE (expr_tree)),			    expr_tree);      return expr_tree;    case FFEINTRIN_impCMPLX:      real_type = ffecom_tree_type[FFEINFO_basictypeREAL][kt];      if (arg2 == NULL)	return	  convert (tree_type, ffecom_expr (arg1));      return	ffecom_2 (COMPLEX_EXPR, tree_type,		  convert (real_type, ffecom_expr (arg1)),		  convert (real_type,			   ffecom_expr (arg2)));    case FFEINTRIN_impCONJG:	/* Plus impDCONJG. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtCONJG;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtDCONJG;      else	{	  assert ("bad CONJG kind type" == NULL);	  ix = FFECOM_gfrt;	}      dest_used = NULL;		/* These don't work with overlapping result. */      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impCOS:	/* Plus impCCOS, impCDCOS, impDCOS. */      if (bt == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCCOS;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDCOS;	  else	    {	      assert ("bad COS COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  dest_used = NULL;		/* These don't work with overlapping result. */	}      else	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtL_COS;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtL_COS;	  else	    {	      assert ("bad COS REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impCOSH:	/* Plus impDCOSH. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_COSH;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_COSH;      else	{	  assert ("bad COSH kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impDBLE:      return convert (tree_type, ffecom_expr (arg1));    case FFEINTRIN_impDIM:	/* Plus impDDIM, impIDIM. */      saved_expr1 = ffecom_save_tree (convert (tree_type,					       ffecom_expr (arg1)));      saved_expr2 = ffecom_save_tree (convert (tree_type,					       ffecom_expr (arg2)));      return	ffecom_3 (COND_EXPR, tree_type,		  ffecom_truth_value		  (ffecom_2 (GT_EXPR, integer_type_node,			     saved_expr1,			     saved_expr2)),		  ffecom_2 (MINUS_EXPR, tree_type,			    saved_expr1,			    saved_expr2),		  convert (tree_type, ffecom_float_zero_));    case FFEINTRIN_impDPROD:      return	ffecom_2 (MULT_EXPR, tree_type,		  convert (tree_type, ffecom_expr (arg1)),		  convert (tree_type, ffecom_expr (arg2)));    case FFEINTRIN_impEXP:	/* Plus impCEXP, impCDEXP, impDEXP. */      if (bt == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCEXP;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDEXP;	  else	    {	      assert ("bad EXP COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  dest_used = NULL;		/* These don't work with overlapping result. */	}      else	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtL_EXP;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtL_EXP;	  else	    {	      assert ("bad EXP REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impICHAR:    case FFEINTRIN_impIACHAR:#if 0				/* The simple approach. */      ffecom_char_args_ (&expr_tree, &saved_expr1 /* Ignored */ , arg1);      expr_tree	= ffecom_1 (INDIRECT_REF,		    TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (expr_tree))),		    expr_tree);      expr_tree	= ffecom_2 (ARRAY_REF,		    TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (expr_tree))),		    expr_tree,		    integer_one_node);      return convert (tree_type, expr_tree);#else /* The more interesting (and more optimal) approach. */      expr_tree = ffecom_intrinsic_ichar_ (tree_type, arg1, &saved_expr1);      expr_tree = ffecom_3 (COND_EXPR, tree_type,			    saved_expr1,			    expr_tree,			    convert (tree_type, integer_zero_node));      return expr_tree;#endif    case FFEINTRIN_impINDEX:      break;    case FFEINTRIN_impINT:      return convert (tree_type, ffecom_expr (arg1));    case FFEINTRIN_impLEN:#if 0				/* The simple approach. */      break;#else /* The more interesting (and more optimal) approach. */      return ffecom_intrinsic_len_ (arg1);#endif    case FFEINTRIN_impLGE:      break;    case FFEINTRIN_impLGT:      break;    case FFEINTRIN_impLLE:      break;    case FFEINTRIN_impLLT:      break;    case FFEINTRIN_impLOG:	/* For impALOG, impCLOG, impCDLOG, impDLOG. */      if (bt == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCLOG;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDLOG;	  else	    {	      assert ("bad LOG COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  dest_used = NULL;		/* These don't work with overlapping result. */	}      else	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtL_LOG;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtL_LOG;	  else	    {	      assert ("bad LOG REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impLOG10:	/* For impALOG10, impDLOG10. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtALOG10;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtDLOG10;      else	{	  assert ("bad LOG10 kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impMAX:	/* Plus impAMAX0, impAMAX1, impDMAX1,				   impMAX0, impMAX1. */      if (bt != ffeinfo_basictype (ffebld_info (arg1)))	arg1_type = ffecom_widest_expr_type_ (ffebld_right (expr));      else	arg1_type = tree_type;      expr_tree = ffecom_2 (MAX_EXPR, arg1_type,			    convert (arg1_type, ffecom_expr (arg1)),			    convert (arg1_type, ffecom_expr (arg2)));      for (; list != NULL; list = ffebld_trail (list))	{	  if ((ffebld_head (list) == NULL)	      || (ffebld_op (ffebld_head (list)) == FFEBLD_opANY))	    continue;	  expr_tree = ffecom_2 (MAX_EXPR, arg1_type,				expr_tree,				convert (arg1_type,					 ffecom_expr (ffebld_head (list))));	}      return convert (tree_type, expr_tree);    case FFEINTRIN_impMIN:	/* Plus impAMIN0, impAMIN1, impDMIN1,				   impMIN0, impMIN1. */      if (bt != ffeinfo_basictype (ffebld_info (arg1)))	arg1_type = ffecom_widest_expr_type_ (ffebld_right (expr));      else	arg1_type = tree_type;      expr_tree = ffecom_2 (MIN_EXPR, arg1_type,			    convert (arg1_type, ffecom_expr (arg1)),			    convert (arg1_type, ffecom_expr (arg2)));      for (; list != NULL; list = ffebld_trail (list))	{	  if ((ffebld_head (list) == NULL)	      || (ffebld_op (ffebld_head (list)) == FFEBLD_opANY))	    continue;	  expr_tree = ffecom_2 (MIN_EXPR, arg1_type,				expr_tree,				convert (arg1_type,					 ffecom_expr (ffebld_head (list))));	}      return convert (tree_type, expr_tree);    case FFEINTRIN_impMOD:      if (bt == FFEINFO_basictypeREAL)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtAMOD;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtDMOD;	  else	    {	      assert ("bad DMOD REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  goto library;		/* :::::::::::::::::::: */	}      return ffecom_2 (TRUNC_MOD_EXPR, tree_type,		       convert (tree_type, ffecom_expr (arg1)),		       convert (tree_type, ffecom_expr (arg2)));    case FFEINTRIN_impNINT:	/* Plus IDNINT. */#if 0				/* ~~ ideally FIX_ROUND_EXPR would be				   implemented, but it ain't yet */      return ffecom_1 (FIX_ROUND_EXPR, tree_type, ffecom_expr (arg1));#else      /* i__1 = r1 >= 0 ? floor(r1 + .5) : -floor(.5 - r1); */      saved_expr1 = ffecom_save_tree (ffecom_expr (arg1));      return	convert (ffecom_integer_type_node,		 ffecom_3 (COND_EXPR, arg1_type,			   ffecom_truth_value			   (ffecom_2 (GE_EXPR, integer_type_node,				      saved_expr1,				      convert (arg1_type,					       ffecom_float_zero_))),			   ffecom_2 (PLUS_EXPR, arg1_type,				     saved_expr1,				     convert (arg1_type,					      ffecom_float_half_)),			   ffecom_2 (MINUS_EXPR, arg1_type,				     saved_expr1,				     convert (arg1_type,					      ffecom_float_half_))));#endif    case FFEINTRIN_impREAL:      return convert (tree_type, ffecom_expr (arg1));    case FFEINTRIN_impSIGN:	/* Plus impDSIGN, impISIGN. */      {	tree arg2_tree = ffecom_expr (arg2);	saved_expr1	  = ffecom_save_tree	  (ffecom_1 (ABS_EXPR, tree_type,		     convert (tree_type,			      ffecom_expr (arg1))));	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (GE_EXPR, integer_type_node,				 arg2_tree,				 convert (TREE_TYPE (arg2_tree),					  integer_zero_node))),		      saved_expr1,		      ffecom_1 (NEGATE_EXPR, tree_type, saved_expr1));	/* Make sure SAVE_EXPRs get referenced early enough. */	expr_tree	  = ffecom_2 (COMPOUND_EXPR, tree_type,		      convert (void_type_node, saved_expr1),		      expr_tree);      }      return expr_tree;    case FFEINTRIN_impSIN:	/* Plus impCSIN, impCDSIN, impDSIN. */      if (bt == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCSIN;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDSIN;	  else	    {	      assert ("bad SIN COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  dest_used = NULL;		/* These don't work with overlapping result. */	}      else	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtL_SIN;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtL_SIN;	  else	    {	      assert ("bad SIN REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impSINH:	/* Plus impDSINH. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_SINH;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_SINH;      else	{	  assert ("bad SINH kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impSQRT:	/* Plus impCSQRT, impCDSQRT, impDSQRT. */      if (bt == FFEINFO_basictypeCOMPLEX)	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtCSQRT;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtCDSQRT;	  else	    {	      assert ("bad SQRT COMPLEX kind type" == NULL);	      ix = FFECOM_gfrt;	    }	  dest_used = NULL;		/* These don't work with overlapping result. */	}      else	{	  if (kt == FFEINFO_kindtypeREAL1)	    ix = FFECOM_gfrtL_SQRT;	  else if (kt == FFEINFO_kindtypeREAL2)	    ix = FFECOM_gfrtL_SQRT;	  else	    {	      assert ("bad SQRT REAL kind type" == NULL);	      ix = FFECOM_gfrt;	    }	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impTAN:	/* Plus impDTAN. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_TAN;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_TAN;      else	{	  assert ("bad TAN kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impTANH:	/* Plus impDTANH. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_TANH;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_TANH;      else	{	  assert ("bad TANH kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impIAND:      return ffecom_2 (BIT_AND_EXPR, tree_type,		       convert (tree_type,				ffecom_expr (arg1)),		       convert (tree_type,				ffecom_expr (arg2)));    case FFEINTRIN_impIOR:      return ffecom_2 (BIT_IOR_EXPR, tree_type,		       convert (tree_type,				ffecom_expr (arg1)),		       convert (tree_type,				ffecom_expr (arg2)));    case FFEINTRIN_impIEOR:      return ffecom_2 (BIT_XOR_EXPR, tree_type,		       convert (tree_type,				ffecom_expr (arg1)),		       convert (tree_type,				ffecom_expr (arg2)));    case FFEINTRIN_impLSHIFT:      return ffecom_2 (LSHIFT_EXPR, tree_type,		       ffecom_expr (arg1),		       convert (integer_type_node,				ffecom_expr (arg2)));    case FFEINTRIN_impRSHIFT:      return ffecom_2 (RSHIFT_EXPR, tree_type,		       ffecom_expr (arg1),		       convert (integer_type_node,				ffecom_expr (arg2)));    case FFEINTRIN_impNOT:      return ffecom_1 (BIT_NOT_EXPR, tree_type, ffecom_expr (arg1));    case FFEINTRIN_impBIT_SIZE:      return convert (tree_type, TYPE_SIZE (arg1_type));    case FFEINTRIN_impBTEST:      {	ffetargetLogical1 true;	ffetargetLogical1 false;	tree true_tree;	tree false_tree;	ffetarget_logical1 (&true, TRUE);	ffetarget_logical1 (&false, FALSE);	if (true == 1)	  true_tree = convert (tree_type, integer_one_node);	else	  true_tree = convert (tree_type, build_int_2 (true, 0));	if (false == 0)	  false_tree = convert (tree_type, integer_zero_node);	else	  false_tree = convert (tree_type, build_int_2 (false, 0));	return	  ffecom_3 (COND_EXPR, tree_type,		    ffecom_truth_value		    (ffecom_2 (EQ_EXPR, integer_type_node,			       ffecom_2 (BIT_AND_EXPR, arg1_type,					 ffecom_expr (arg1),					 ffecom_2 (LSHIFT_EXPR, arg1_type,						   convert (arg1_type,							  integer_one_node),						   convert (integer_type_node,							    ffecom_expr (arg2)))),			       convert (arg1_type,					integer_zero_node))),		    false_tree,		    true_tree);      }    case FFEINTRIN_impIBCLR:      return	ffecom_2 (BIT_AND_EXPR, tree_type,		  ffecom_expr (arg1),		  ffecom_1 (BIT_NOT_EXPR, tree_type,			    ffecom_2 (LSHIFT_EXPR, tree_type,				      convert (tree_type,					       integer_one_node),				      convert (integer_type_node,					       ffecom_expr (arg2)))));    case FFEINTRIN_impIBITS:      {	tree arg3_tree = ffecom_save_tree (convert (integer_type_node,						    ffecom_expr (arg3)));	tree uns_type	= ffecom_tree_type[FFEINFO_basictypeHOLLERITH][kt];	expr_tree	  = ffecom_2 (BIT_AND_EXPR, tree_type,		      ffecom_2 (RSHIFT_EXPR, tree_type,				ffecom_expr (arg1),				convert (integer_type_node,					 ffecom_expr (arg2))),		      convert (tree_type,			       ffecom_2 (RSHIFT_EXPR, uns_type,					 ffecom_1 (BIT_NOT_EXPR,						   uns_type,						   convert (uns_type,							integer_zero_node)),					 ffecom_2 (MINUS_EXPR,						   integer_type_node,						   TYPE_SIZE (uns_type),						   arg3_tree))));#if !defined(TREE_SHIFT_FULLWIDTH) || !TREE_SHIFT_FULLWIDTH	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg3_tree,				 integer_zero_node)),		      expr_tree,		      convert (tree_type, integer_zero_node));#endif      }      return expr_tree;    case FFEINTRIN_impIBSET:      return	ffecom_2 (BIT_IOR_EXPR, tree_type,		  ffecom_expr (arg1),		  ffecom_2 (LSHIFT_EXPR, tree_type,			    convert (tree_type, integer_one_node),			    convert (integer_type_node,				     ffecom_expr (arg2))));    case FFEINTRIN_impISHFT:      {	tree arg1_tree = ffecom_save_tree (ffecom_expr (arg1));	tree arg2_tree = ffecom_save_tree (convert (integer_type_node,						    ffecom_expr (arg2)));	tree uns_type	= ffecom_tree_type[FFEINFO_basictypeHOLLERITH][kt];	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (GE_EXPR, integer_type_node,				 arg2_tree,				 integer_zero_node)),		      ffecom_2 (LSHIFT_EXPR, tree_type,				arg1_tree,				arg2_tree),		      convert (tree_type,			       ffecom_2 (RSHIFT_EXPR, uns_type,					 convert (uns_type, arg1_tree),					 ffecom_1 (NEGATE_EXPR,						   integer_type_node,						   arg2_tree))));#if !defined(TREE_SHIFT_FULLWIDTH) || !TREE_SHIFT_FULLWIDTH	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg2_tree,				 TYPE_SIZE (uns_type))),		      expr_tree,		      convert (tree_type, integer_zero_node));#endif	/* Make sure SAVE_EXPRs get referenced early enough. */	expr_tree	  = ffecom_2 (COMPOUND_EXPR, tree_type,		      convert (void_type_node, arg1_tree),		      ffecom_2 (COMPOUND_EXPR, tree_type,				convert (void_type_node, arg2_tree),				expr_tree));      }      return expr_tree;    case FFEINTRIN_impISHFTC:      {	tree arg1_tree = ffecom_save_tree (ffecom_expr (arg1));	tree arg2_tree = ffecom_save_tree (convert (integer_type_node,						    ffecom_expr (arg2)));	tree arg3_tree = (arg3 == NULL) ? TYPE_SIZE (tree_type)	: ffecom_save_tree (convert (integer_type_node, ffecom_expr (arg3)));	tree shift_neg;	tree shift_pos;	tree mask_arg1;	tree masked_arg1;	tree uns_type	= ffecom_tree_type[FFEINFO_basictypeHOLLERITH][kt];	mask_arg1	  = ffecom_2 (LSHIFT_EXPR, tree_type,		      ffecom_1 (BIT_NOT_EXPR, tree_type,				convert (tree_type, integer_zero_node)),		      arg3_tree);#if !defined(TREE_SHIFT_FULLWIDTH) || !TREE_SHIFT_FULLWIDTH	mask_arg1	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg3_tree,				 TYPE_SIZE (uns_type))),		      mask_arg1,		      convert (tree_type, integer_zero_node));#endif	mask_arg1 = ffecom_save_tree (mask_arg1);	masked_arg1	  = ffecom_2 (BIT_AND_EXPR, tree_type,		      arg1_tree,		      ffecom_1 (BIT_NOT_EXPR, tree_type,				mask_arg1));	masked_arg1 = ffecom_save_tree (masked_arg1);	shift_neg	  = ffecom_2 (BIT_IOR_EXPR, tree_type,		      convert (tree_type,			       ffecom_2 (RSHIFT_EXPR, uns_type,					 convert (uns_type, masked_arg1),					 ffecom_1 (NEGATE_EXPR,						   integer_type_node,						   arg2_tree))),		      ffecom_2 (LSHIFT_EXPR, tree_type,				arg1_tree,				ffecom_2 (PLUS_EXPR, integer_type_node,					  arg2_tree,					  arg3_tree)));	shift_pos	  = ffecom_2 (BIT_IOR_EXPR, tree_type,		      ffecom_2 (LSHIFT_EXPR, tree_type,				arg1_tree,				arg2_tree),		      convert (tree_type,			       ffecom_2 (RSHIFT_EXPR, uns_type,					 convert (uns_type, masked_arg1),					 ffecom_2 (MINUS_EXPR,						   integer_type_node,						   arg3_tree,						   arg2_tree))));	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (LT_EXPR, integer_type_node,				 arg2_tree,				 integer_zero_node)),		      shift_neg,		      shift_pos);	expr_tree	  = ffecom_2 (BIT_IOR_EXPR, tree_type,		      ffecom_2 (BIT_AND_EXPR, tree_type,				mask_arg1,				arg1_tree),		      ffecom_2 (BIT_AND_EXPR, tree_type,				ffecom_1 (BIT_NOT_EXPR, tree_type,					  mask_arg1),				expr_tree));	expr_tree	  = ffecom_3 (COND_EXPR, tree_type,		      ffecom_truth_value		      (ffecom_2 (TRUTH_ORIF_EXPR, integer_type_node,				 ffecom_2 (EQ_EXPR, integer_type_node,					   ffecom_1 (ABS_EXPR,						     integer_type_node,						     arg2_tree),					   arg3_tree),				 ffecom_2 (EQ_EXPR, integer_type_node,					   arg2_tree,					   integer_zero_node))),		      arg1_tree,		      expr_tree);	/* Make sure SAVE_EXPRs get referenced early enough. */	expr_tree	  = ffecom_2 (COMPOUND_EXPR, tree_type,		      convert (void_type_node, arg1_tree),		      ffecom_2 (COMPOUND_EXPR, tree_type,				convert (void_type_node, arg2_tree),				ffecom_2 (COMPOUND_EXPR, tree_type,					  convert (void_type_node,						   mask_arg1),					  ffecom_2 (COMPOUND_EXPR, tree_type,						    convert (void_type_node,							     masked_arg1),						    expr_tree))));	expr_tree	  = ffecom_2 (COMPOUND_EXPR, tree_type,		      convert (void_type_node,			       arg3_tree),		      expr_tree);      }      return expr_tree;    case FFEINTRIN_impLOC:      {	tree arg1_tree = ffecom_expr (arg1);	expr_tree	  = convert (tree_type,		     ffecom_1 (ADDR_EXPR,			       build_pointer_type (TREE_TYPE (arg1_tree)),			       arg1_tree));      }      return expr_tree;    case FFEINTRIN_impMVBITS:      {	tree arg1_tree;	tree arg2_tree = convert (integer_type_node,				  ffecom_expr (arg2));	tree arg3_tree = ffecom_save_tree (convert (integer_type_node,						    ffecom_expr (arg3)));	ffebld arg4 = ffebld_head (ffebld_trail (list));	tree arg4_tree;	tree arg4_type;	ffebld arg5 = ffebld_head (ffebld_trail (ffebld_trail (list)));	tree arg5_tree = ffecom_save_tree (convert (integer_type_node,						    ffecom_expr (arg5)));	tree prep_arg1;	tree prep_arg4;	tree arg5_plus_arg3;	arg4_tree = ffecom_expr_rw (arg4);	arg4_type = TREE_TYPE (arg4_tree);	arg1_tree = ffecom_save_tree (convert (arg4_type,					       ffecom_expr (arg1)));	prep_arg1	  = ffecom_2 (LSHIFT_EXPR, arg4_type,		      ffecom_2 (BIT_AND_EXPR, arg4_type,				ffecom_2 (RSHIFT_EXPR, arg4_type,					  arg1_tree,					  arg2_tree),				ffecom_1 (BIT_NOT_EXPR, arg4_type,					  ffecom_2 (LSHIFT_EXPR, arg4_type,						    ffecom_1 (BIT_NOT_EXPR,							      arg4_type,							      convert							      (arg4_type,							integer_zero_node)),						    arg3_tree))),		      arg5_tree);	arg5_plus_arg3	  = ffecom_save_tree (ffecom_2 (PLUS_EXPR, arg4_type,					arg5_tree,					arg3_tree));	prep_arg4	  = ffecom_2 (LSHIFT_EXPR, arg4_type,		      ffecom_1 (BIT_NOT_EXPR, arg4_type,				convert (arg4_type,					 integer_zero_node)),		      arg5_plus_arg3);#if !defined(TREE_SHIFT_FULLWIDTH) || !TREE_SHIFT_FULLWIDTH	prep_arg4	  = ffecom_3 (COND_EXPR, arg4_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg5_plus_arg3,				 convert (TREE_TYPE (arg5_plus_arg3),					  TYPE_SIZE (arg4_type)))),		      prep_arg4,		      convert (arg4_type, integer_zero_node));#endif	prep_arg4	  = ffecom_2 (BIT_AND_EXPR, arg4_type,		      arg4_tree,		      ffecom_2 (BIT_IOR_EXPR, arg4_type,				prep_arg4,				ffecom_1 (BIT_NOT_EXPR, arg4_type,					  ffecom_2 (LSHIFT_EXPR, arg4_type,						    ffecom_1 (BIT_NOT_EXPR,							      arg4_type,							      convert							      (arg4_type,							integer_zero_node)),						    arg5_tree))));	prep_arg1	  = ffecom_2 (BIT_IOR_EXPR, arg4_type,		      prep_arg1,		      prep_arg4);#if !defined(TREE_SHIFT_FULLWIDTH) || !TREE_SHIFT_FULLWIDTH	prep_arg1	  = ffecom_3 (COND_EXPR, arg4_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg3_tree,				 convert (TREE_TYPE (arg3_tree),					  integer_zero_node))),		      prep_arg1,		      arg4_tree);	prep_arg1	  = ffecom_3 (COND_EXPR, arg4_type,		      ffecom_truth_value		      (ffecom_2 (NE_EXPR, integer_type_node,				 arg3_tree,				 convert (TREE_TYPE (arg3_tree),					  TYPE_SIZE (arg4_type)))),		      prep_arg1,		      arg1_tree);#endif	expr_tree	  = ffecom_2s (MODIFY_EXPR, void_type_node,		       arg4_tree,		       prep_arg1);	/* Make sure SAVE_EXPRs get referenced early enough. */	expr_tree	  = ffecom_2 (COMPOUND_EXPR, void_type_node,		      arg1_tree,		      ffecom_2 (COMPOUND_EXPR, void_type_node,				arg3_tree,				ffecom_2 (COMPOUND_EXPR, void_type_node,					  arg5_tree,					  ffecom_2 (COMPOUND_EXPR, void_type_node,						    arg5_plus_arg3,						    expr_tree))));	expr_tree	  = ffecom_2 (COMPOUND_EXPR, void_type_node,		      arg4_tree,		      expr_tree);      }      return expr_tree;    case FFEINTRIN_impERF:	/* Plus impDERF. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ERF;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ERF;      else	{	  assert ("bad ERF kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impERFC:	/* Plus impDERFC. */      if (kt == FFEINFO_kindtypeREAL1)	ix = FFECOM_gfrtL_ERFC;      else if (kt == FFEINFO_kindtypeREAL2)	ix = FFECOM_gfrtL_ERFC;      else	{	  assert ("bad ERFC kind type" == NULL);	  ix = FFECOM_gfrt;	}      goto library;		/* :::::::::::::::::::: */    case FFEINTRIN_impIARGC:      /* extern int xargc; i__1 = xargc - 1; */      expr_tree = ffecom_2 (MINUS_EXPR, TREE_TYPE (ffecom_tree_xargc_),			    ffecom_tree_xargc_,			    convert (TREE_TYPE (ffecom_tree_xargc_),				     integer_one_node));      return expr_tree;    case FFEINTRIN_impSIGNAL:      {	tree arg1_tree;	tree arg2_tree;	tree arg3_tree;	ffecom_push_calltemps ();	arg1_tree = convert (ffecom_f2c_integer_type_node,			     ffecom_expr (arg1));	arg1_tree = ffecom_1 (ADDR_EXPR,			      build_pointer_type (TREE_TYPE (arg1_tree)),			      arg1_tree);	/* Pass procedure as a pointer to it, anything else by value.  */	if (ffeinfo_kind (ffebld_info (arg2)) == FFEINFO_kindENTITY)	  arg2_tree = ffecom_expr (arg2);	else	  arg2_tree = ffecom_ptr_to_expr (arg2);	arg2_tree = convert (TREE_TYPE (null_pointer_node),			     arg2_tree);	if (arg3 != NULL)	  arg3_tree = ffecom_expr_rw (arg3);	else	  arg3_tree = NULL_TREE;	ffecom_pop_calltemps ();	arg1_tree = build_tree_list (NULL_TREE, arg1_tree);	arg2_tree = build_tree_list (NULL_TREE, arg2_tree);	TREE_CHAIN (arg1_tree) = arg2_tree;	expr_tree	  = ffecom_call_ (ffecom_gfrt_tree_ (FFECOM_gfrtSIGNAL),			  ffecom_gfrt_kind_type_ (FFECOM_gfrtSIGNAL),			  FALSE,			  integer_type_node,			  arg1_tree,			  NULL_TREE, NULL, NULL, NULL_TREE, TRUE);	if (arg3_tree != NULL_TREE)	  expr_tree	    = ffecom_modify (NULL_TREE, arg3_tree,			     convert (TREE_TYPE (arg3_tree),				      expr_tree));      }      return expr_tree;    case FFEINTRIN_impSYSTEM:      {	tree arg1_len = integer_zero_node;	tree arg1_tree;	tree arg2_tree;	ffecom_push_calltemps ();	arg1_tree = ffecom_arg_ptr_to_expr (arg1, &arg1_len);	if (arg2 != NULL)	  arg2_tree = ffecom_expr_rw (arg2);	else	  arg2_tree = NULL_TREE;	ffecom_pop_calltemps ();	arg1_tree = build_tree_list (NULL_TREE, arg1_tree);	arg1_len = build_tree_list (NULL_TREE, arg1_len);	TREE_CHAIN (arg1_tree) = arg1_len;	expr_tree	  = ffecom_call_ (ffecom_gfrt_tree_ (FFECOM_gfrtSYSTEM),			  ffecom_gfrt_kind_type_ (FFECOM_gfrtSYSTEM),			  FALSE,			  integer_type_node,			  arg1_tree,			  NULL_TREE, NULL, NULL, NULL_TREE, TRUE);	if (arg2_tree != NULL_TREE)	  expr_tree	    = ffecom_modify (NULL_TREE, arg2_tree,			     convert (TREE_TYPE (arg2_tree),				      expr_tree));      }      return expr_tree;    case FFEINTRIN_impEXIT:      if (arg1 != NULL)	break;#ifdef VMS_TARGET      expr_tree = ffecom_integer_zero_node;	/* C lib translates this!! */#else      expr_tree = ffecom_integer_zero_node;#endif      expr_tree = build_tree_list (NULL_TREE,				   ffecom_1 (ADDR_EXPR,					     build_pointer_type					     (ffecom_integer_type_node),					     expr_tree));      return	ffecom_call_ (ffecom_gfrt_tree_ (FFECOM_gfrtEXIT),		      ffecom_gfrt_kind_type_ (FFECOM_gfrtEXIT),		      FALSE,		      void_type_node,		      expr_tree,		      NULL_TREE, NULL, NULL, NULL_TREE, TRUE);    case FFEINTRIN_impFLUSH:      /* Ignore the arg, since the library has no use for it yet.  */      return	ffecom_call_ (ffecom_gfrt_tree_ (FFECOM_gfrtFLUSH),		      ffecom_gfrt_kind_type_ (FFECOM_gfrtFLUSH),		      FALSE,		      void_type_node,		      NULL_TREE,		      NULL_TREE, NULL, NULL, NULL_TREE, TRUE);    case FFEINTRIN_impABORT:    case FFEINTRIN_impGETARG:    case FFEINTRIN_impGETENV:    case FFEINTRIN_impFTELL:    case FFEINTRIN_impFSEEK:      break;    default:      fprintf (stderr, "No %s implementation.\n",	       ffeintrin_name_implementation (ffeintrin_codegen_imp					      (ffebld_symter_implementation (ffebld_left (expr)))));      assert ("unimplemented intrinsic" == NULL);      return error_mark_node;    }  ix = ffeintrin_gfrt (ffebld_symter_implementation (ffebld_left (expr)));library:			/* :::::::::::::::::::: */  assert (ix != FFECOM_gfrt);	/* Must have an implementation! */  ffecom_push_calltemps ();  expr_tree = ffecom_arglist_expr_ (ffecom_gfrt_args_ (ix),				    ffebld_right (expr));  ffecom_pop_calltemps ();  return ffecom_call_ (ffecom_gfrt_tree_ (ix), ffecom_gfrt_kind_type_ (ix),		       (ffe_is_f2c_library () && ffecom_gfrt_complex_[ix]),		       tree_type,		       expr_tree, dest_tree, dest, dest_used,		       NULL_TREE, TRUE);  /**INDENT* (Do not reformat this comment even with -fca option.)   Data-gathering files: Given the source file listed below, compiled with   f2c I obtained the output file listed after that, and from the output   file I derived the above code.-------- (begin input file to f2c)	implicit none	character*10 A1,A2	complex C1,C2	integer I1,I2	real R1,R2	double precision D1,D2C	call getem(A1,A2,C1,C2,I1,I2,R1,R2,D1,D2)c /	call fooI(I1/I2)	call fooR(R1/I1)	call fooD(D1/I1)	call fooC(C1/I1)	call fooR(R1/R2)	call fooD(R1/D1)	call fooD(D1/D2)	call fooD(D1/R1)	call fooC(C1/C2)	call fooC(C1/R1)	call fooZ(C1/D1)c **	call fooI(I1**I2)	call fooR(R1**I1)	call fooD(D1**I1)	call fooC(C1**I1)	call fooR(R1**R2)	call fooD(R1**D1)	call fooD(D1**D2)	call fooD(D1**R1)	call fooC(C1**C2)	call fooC(C1**R1)	call fooZ(C1**D1)c FFEINTRIN_impABS	call fooR(ABS(R1))c FFEINTRIN_impACOS	call fooR(ACOS(R1))c FFEINTRIN_impAIMAG	call fooR(AIMAG(C1))c FFEINTRIN_impAINT	call fooR(AINT(R1))c FFEINTRIN_impALOG	call fooR(ALOG(R1))c FFEINTRIN_impALOG10	call fooR(ALOG10(R1))c FFEINTRIN_impAMAX0	call fooR(AMAX0(I1,I2))c FFEINTRIN_impAMAX1	call fooR(AMAX1(R1,R2))c FFEINTRIN_impAMIN0	call fooR(AMIN0(I1,I2))c FFEINTRIN_impAMIN1	call fooR(AMIN1(R1,R2))c FFEINTRIN_impAMOD	call fooR(AMOD(R1,R2))c FFEINTRIN_impANINT	call fooR(ANINT(R1))c FFEINTRIN_impASIN	call fooR(ASIN(R1))c FFEINTRIN_impATAN	call fooR(ATAN(R1))c FFEINTRIN_impATAN2	call fooR(ATAN2(R1,R2))c FFEINTRIN_impCABS	call fooR(CABS(C1))c FFEINTRIN_impCCOS	call fooC(CCOS(C1))c FFEINTRIN_impCEXP	call fooC(CEXP(C1))c FFEINTRIN_impCHAR	call fooA(CHAR(I1))c FFEINTRIN_impCLOG	call fooC(CLOG(C1))c FFEINTRIN_impCONJG	call fooC(CONJG(C1))c FFEINTRIN_impCOS	call fooR(COS(R1))c FFEINTRIN_impCOSH	call fooR(COSH(R1))c FFEINTRIN_impCSIN	call fooC(CSIN(C1))c FFEINTRIN_impCSQRT	call fooC(CSQRT(C1))c FFEINTRIN_impDABS	call fooD(DABS(D1))c FFEINTRIN_impDACOS	call fooD(DACOS(D1))c FFEINTRIN_impDASIN	call fooD(DASIN(D1))c FFEINTRIN_impDATAN	call fooD(DATAN(D1))c FFEINTRIN_impDATAN2	call fooD(DATAN2(D1,D2))c FFEINTRIN_impDCOS	call fooD(DCOS(D1))c FFEINTRIN_impDCOSH	call fooD(DCOSH(D1))c FFEINTRIN_impDDIM	call fooD(DDIM(D1,D2))c FFEINTRIN_impDEXP	call fooD(DEXP(D1))c FFEINTRIN_impDIM	call fooR(DIM(R1,R2))c FFEINTRIN_impDINT	call fooD(DINT(D1))c FFEINTRIN_impDLOG	call fooD(DLOG(D1))c FFEINTRIN_impDLOG10	call fooD(DLOG10(D1))c FFEINTRIN_impDMAX1	call fooD(DMAX1(D1,D2))c FFEINTRIN_impDMIN1	call fooD(DMIN1(D1,D2))c FFEINTRIN_impDMOD	call fooD(DMOD(D1,D2))c FFEINTRIN_impDNINT	call fooD(DNINT(D1))c FFEINTRIN_impDPROD	call fooD(DPROD(R1,R2))c FFEINTRIN_impDSIGN	call fooD(DSIGN(D1,D2))c FFEINTRIN_impDSIN	call fooD(DSIN(D1))c FFEINTRIN_impDSINH	call fooD(DSINH(D1))c FFEINTRIN_impDSQRT	call fooD(DSQRT(D1))c FFEINTRIN_impDTAN	call fooD(DTAN(D1))c FFEINTRIN_impDTANH	call fooD(DTANH(D1))c FFEINTRIN_impEXP	call fooR(EXP(R1))c FFEINTRIN_impIABS	call fooI(IABS(I1))c FFEINTRIN_impICHAR	call fooI(ICHAR(A1))c FFEINTRIN_impIDIM	call fooI(IDIM(I1,I2))c FFEINTRIN_impIDNINT	call fooI(IDNINT(D1))c FFEINTRIN_impINDEX	call fooI(INDEX(A1,A2))c FFEINTRIN_impISIGN	call fooI(ISIGN(I1,I2))c FFEINTRIN_impLEN	call fooI(LEN(A1))c FFEINTRIN_impLGE	call fooL(LGE(A1,A2))c FFEINTRIN_impLGT	call fooL(LGT(A1,A2))c FFEINTRIN_impLLE	call fooL(LLE(A1,A2))c FFEINTRIN_impLLT	call fooL(LLT(A1,A2))c FFEINTRIN_impMAX0	call fooI(MAX0(I1,I2))c FFEINTRIN_impMAX1	call fooI(MAX1(R1,R2))c FFEINTRIN_impMIN0	call fooI(MIN0(I1,I2))c FFEINTRIN_impMIN1	call fooI(MIN1(R1,R2))c FFEINTRIN_impMOD	call fooI(MOD(I1,I2))c FFEINTRIN_impNINT	call fooI(NINT(R1))c FFEINTRIN_impSIGN	call fooR(SIGN(R1,R2))c FFEINTRIN_impSIN	call fooR(SIN(R1))c FFEINTRIN_impSINH	call fooR(SINH(R1))c FFEINTRIN_impSQRT	call fooR(SQRT(R1))c FFEINTRIN_impTAN	call fooR(TAN(R1))c FFEINTRIN_impTANH	call fooR(TANH(R1))c FFEINTRIN_imp_CMPLX_C	call fooC(cmplx(C1,C2))c FFEINTRIN_imp_CMPLX_D	call fooZ(cmplx(D1,D2))c FFEINTRIN_imp_CMPLX_I	call fooC(cmplx(I1,I2))c FFEINTRIN_imp_CMPLX_R	call fooC(cmplx(R1,R2))c FFEINTRIN_imp_DBLE_C	call fooD(dble(C1))c FFEINTRIN_imp_DBLE_D	call fooD(dble(D1))c FFEINTRIN_imp_DBLE_I	call fooD(dble(I1))c FFEINTRIN_imp_DBLE_R	call fooD(dble(R1))c FFEINTRIN_imp_INT_C	call fooI(int(C1))c FFEINTRIN_imp_INT_D	call fooI(int(D1))c FFEINTRIN_imp_INT_I	call fooI(int(I1))c FFEINTRIN_imp_INT_R	call fooI(int(R1))c FFEINTRIN_imp_REAL_C	call fooR(real(C1))c FFEINTRIN_imp_REAL_D	call fooR(real(D1))c FFEINTRIN_imp_REAL_I	call fooR(real(I1))c FFEINTRIN_imp_REAL_R	call fooR(real(R1))cc FFEINTRIN_imp_INT_D:cc FFEINTRIN_specIDINT	call fooI(IDINT(D1))cc FFEINTRIN_imp_INT_R:cc FFEINTRIN_specIFIX	call fooI(IFIX(R1))c FFEINTRIN_specINT	call fooI(INT(R1))cc FFEINTRIN_imp_REAL_D:cc FFEINTRIN_specSNGL	call fooR(SNGL(D1))cc FFEINTRIN_imp_REAL_I:cc FFEINTRIN_specFLOAT	call fooR(FLOAT(I1))c FFEINTRIN_specREAL	call fooR(REAL(I1))c	end-------- (end input file to f2c)-------- (begin output from providing above input file as input to:--------  `f2c | gcc -E -C - | sed -e "s:/[*]*://:g" -e "s:[*]*[/]://:g" \--------     -e "s:^#.*$::g"')//  -- translated by f2c (version 19950223).   You must link the resulting object file with the libraries:        -lf2c -lm   (in that order)//// f2c.h  --  Standard Fortran to C header file /////  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."        - From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) //// F2C_INTEGER will normally be `int' but would be `long' on 16-bit systems //// we assume short, float are OK //typedef long int // long int // integer;typedef char *address;typedef short int shortint;typedef float real;typedef double doublereal;typedef struct { real r, i; } complex;typedef struct { doublereal r, i; } doublecomplex;typedef long int // long int // logical;typedef short int shortlogical;typedef char logical1;typedef char integer1;// typedef long long longint; // // system-dependent //// Extern is for use with -E //// I/O stuff //typedef long int // int or long int // flag;typedef long int // int or long int // ftnlen;typedef long int // int or long int // ftnint;//external read, write//typedef struct{       flag cierr;        ftnint ciunit;        flag ciend;        char *cifmt;        ftnint cirec;} cilist;//internal read, write//typedef struct{       flag icierr;        char *iciunit;        flag iciend;        char *icifmt;        ftnint icirlen;        ftnint icirnum;} icilist;//open//typedef struct{       flag oerr;        ftnint ounit;        char *ofnm;        ftnlen ofnmlen;        char *osta;        char *oacc;        char *ofm;        ftnint orl;        char *oblnk;} olist;//close//typedef struct{       flag cerr;        ftnint cunit;        char *csta;} cllist;//rewind, backspace, endfile//typedef struct{       flag aerr;        ftnint aunit;} alist;// inquire //typedef struct{       flag inerr;        ftnint inunit;        char *infile;        ftnlen infilen;        ftnint  *inex;  //parameters in standard's order//        ftnint  *inopen;        ftnint  *innum;        ftnint  *innamed;        char    *inname;        ftnlen  innamlen;        char    *inacc;        ftnlen  inacclen;        char    *inseq;        ftnlen  inseqlen;        char    *indir;        ftnlen  indirlen;        char    *infmt;        ftnlen  infmtlen;        char    *inform;        ftnint  informlen;        char    *inunf;        ftnlen  inunflen;        ftnint  *inrecl;        ftnint  *innrec;        char    *inblank;        ftnlen  inblanklen;} inlist;union Multitype {       // for multiple entry points //        integer1 g;        shortint h;        integer i;        // longint j; //        real r;        doublereal d;        complex c;        doublecomplex z;        };typedef union Multitype Multitype;typedef long Long;      // No longer used; formerly in Namelist //struct Vardesc {        // for Namelist //        char *name;        char *addr;        ftnlen *dims;        int  type;        };typedef struct Vardesc Vardesc;struct Namelist {        char *name;        Vardesc **vars;        int nvars;        };typedef struct Namelist Namelist;// procedure parameter types for -A and -C++ //typedef int // Unknown procedure type // (*U_fp)();typedef shortint (*J_fp)();typedef integer (*I_fp)();typedef real (*R_fp)();typedef doublereal (*D_fp)(), (*E_fp)();typedef // Complex // void  (*C_fp)();typedef // Double Complex // void  (*Z_fp)();typedef logical (*L_fp)();typedef shortlogical (*K_fp)();typedef // Character // void  (*H_fp)();typedef // Subroutine // int (*S_fp)();// E_fp is for real functions when -R is not specified //typedef void  C_f;      // complex function //typedef void  H_f;      // character function //typedef void  Z_f;      // double complex function //typedef doublereal E_f; // real function with -R not specified //// undef any lower-case symbols that your C compiler predefines, e.g.: //// (No such symbols should be defined in a strict ANSI C compiler.   We can avoid trouble with f2c-translated code by using   gcc -ansi [-traditional].) //// Main program // MAIN__(){    // System generated locals //    integer i__1;    real r__1, r__2;    doublereal d__1, d__2;    complex q__1;    doublecomplex z__1, z__2, z__3;    logical L__1;    char ch__1[1];    // Builtin functions //    void c_div();    integer pow_ii();    double pow_ri(), pow_di();    void pow_ci();    double pow_dd();    void pow_zz();    double acos(), r_imag(), r_int(), log(), r_lg10(), r_mod(), r_nint(),             asin(), atan(), atan2(), c_abs();    void c_cos(), c_exp(), c_log(), r_cnjg();    double cos(), cosh();    void c_sin(), c_sqrt();    double d_dim(), exp(), r_dim(), d_int(), d_lg10(), d_mod(), d_nint(),             d_sign(), sin(), sinh(), sqrt(), tan(), tanh();    integer i_dim(), i_dnnt(), i_indx(), i_sign(), i_len();    logical l_ge(), l_gt(), l_le(), l_lt();    integer i_nint();    double r_sign();    // Local variables //    extern // Subroutine // int fooa_(), fooc_(), food_(), fooi_(), foor_(),             fool_(), fooz_(), getem_();    static char a1[10], a2[10];    static complex c1, c2;    static doublereal d1, d2;    static integer i1, i2;    static real r1, r2;    getem_(a1, a2, &c1, &c2, &i1, &i2, &r1, &r2, &d1, &d2, 10L, 10L);// / //    i__1 = i1 / i2;    fooi_(&i__1);    r__1 = r1 / i1;    foor_(&r__1);    d__1 = d1 / i1;    food_(&d__1);    d__1 = (doublereal) i1;    q__1.r = c1.r / d__1, q__1.i = c1.i / d__1;    fooc_(&q__1);    r__1 = r1 / r2;    foor_(&r__1);    d__1 = r1 / d1;    food_(&d__1);    d__1 = d1 / d2;    food_(&d__1);    d__1 = d1 / r1;    food_(&d__1);    c_div(&q__1, &c1, &c2);    fooc_(&q__1);    q__1.r = c1.r / r1, q__1.i = c1.i / r1;    fooc_(&q__1);    z__1.r = c1.r / d1, z__1.i = c1.i / d1;    fooz_(&z__1);// ** //    i__1 = pow_ii(&i1, &i2);    fooi_(&i__1);    r__1 = pow_ri(&r1, &i1);    foor_(&r__1);    d__1 = pow_di(&d1, &i1);    food_(&d__1);    pow_ci(&q__1, &c1, &i1);    fooc_(&q__1);    d__1 = (doublereal) r1;    d__2 = (doublereal) r2;    r__1 = pow_dd(&d__1, &d__2);    foor_(&r__1);    d__2 = (doublereal) r1;    d__1 = pow_dd(&d__2, &d1);    food_(&d__1);    d__1 = pow_dd(&d1, &d2);    food_(&d__1);    d__2 = (doublereal) r1;    d__1 = pow_dd(&d1, &d__2);    food_(&d__1);    z__2.r = c1.r, z__2.i = c1.i;    z__3.r = c2.r, z__3.i = c2.i;    pow_zz(&z__1, &z__2, &z__3);    q__1.r = z__1.r, q__1.i = z__1.i;    fooc_(&q__1);    z__2.r = c1.r, z__2.i = c1.i;    z__3.r = r1, z__3.i = 0.;    pow_zz(&z__1, &z__2, &z__3);    q__1.r = z__1.r, q__1.i = z__1.i;    fooc_(&q__1);    z__2.r = c1.r, z__2.i = c1.i;    z__3.r = d1, z__3.i = 0.;    pow_zz(&z__1, &z__2, &z__3);    fooz_(&z__1);// FFEINTRIN_impABS //    r__1 = (doublereal)((  r1  ) >= 0 ? (  r1  ) : -(  r1  ))  ;    foor_(&r__1);// FFEINTRIN_impACOS //    r__1 = acos(r1);    foor_(&r__1);// FFEINTRIN_impAIMAG //    r__1 = r_imag(&c1);    foor_(&r__1);// FFEINTRIN_impAINT //    r__1 = r_int(&r1);    foor_(&r__1);// FFEINTRIN_impALOG //    r__1 = log(r1);    foor_(&r__1);// FFEINTRIN_impALOG10 //    r__1 = r_lg10(&r1);    foor_(&r__1);// FFEINTRIN_impAMAX0 //    r__1 = (real) (( i1 ) >= ( i2 ) ? ( i1 ) : ( i2 )) ;    foor_(&r__1);// FFEINTRIN_impAMAX1 //    r__1 = (doublereal)((  r1  ) >= (  r2  ) ? (  r1  ) : (  r2  ))  ;    foor_(&r__1);// FFEINTRIN_impAMIN0 //    r__1 = (real) (( i1 ) <= ( i2 ) ? ( i1 ) : ( i2 )) ;    foor_(&r__1);// FFEINTRIN_impAMIN1 //    r__1 = (doublereal)((  r1  ) <= (  r2  ) ? (  r1  ) : (  r2  ))  ;    foor_(&r__1);// FFEINTRIN_impAMOD //    r__1 = r_mod(&r1, &r2);    foor_(&r__1);// FFEINTRIN_impANINT //    r__1 = r_nint(&r1);    foor_(&r__1);// FFEINTRIN_impASIN //    r__1 = asin(r1);    foor_(&r__1);// FFEINTRIN_impATAN //    r__1 = atan(r1);    foor_(&r__1);// FFEINTRIN_impATAN2 //    r__1 = atan2(r1, r2);    foor_(&r__1);// FFEINTRIN_impCABS //    r__1 = c_abs(&c1);    foor_(&r__1);// FFEINTRIN_impCCOS //    c_cos(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impCEXP //    c_exp(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impCHAR //    *(unsigned char *)&ch__1[0] = i1;    fooa_(ch__1, 1L);// FFEINTRIN_impCLOG //    c_log(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impCONJG //    r_cnjg(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impCOS //    r__1 = cos(r1);    foor_(&r__1);// FFEINTRIN_impCOSH //    r__1 = cosh(r1);    foor_(&r__1);// FFEINTRIN_impCSIN //    c_sin(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impCSQRT //    c_sqrt(&q__1, &c1);    fooc_(&q__1);// FFEINTRIN_impDABS //    d__1 = (( d1 ) >= 0 ? ( d1 ) : -( d1 )) ;    food_(&d__1);// FFEINTRIN_impDACOS //    d__1 = acos(d1);    food_(&d__1);// FFEINTRIN_impDASIN //    d__1 = asin(d1);    food_(&d__1);// FFEINTRIN_impDATAN //    d__1 = atan(d1);    food_(&d__1);// FFEINTRIN_impDATAN2 //    d__1 = atan2(d1, d2);    food_(&d__1);// FFEINTRIN_impDCOS //    d__1 = cos(d1);    food_(&d__1);// FFEINTRIN_impDCOSH //    d__1 = cosh(d1);    food_(&d__1);// FFEINTRIN_impDDIM //    d__1 = d_dim(&d1, &d2);    food_(&d__1);// FFEINTRIN_impDEXP //    d__1 = exp(d1);    food_(&d__1);// FFEINTRIN_impDIM //    r__1 = r_dim(&r1, &r2);    foor_(&r__1);// FFEINTRIN_impDINT //    d__1 = d_int(&d1);    food_(&d__1);// FFEINTRIN_impDLOG //    d__1 = log(d1);    food_(&d__1);// FFEINTRIN_impDLOG10 //    d__1 = d_lg10(&d1);    food_(&d__1);// FFEINTRIN_impDMAX1 //    d__1 = (( d1 ) >= ( d2 ) ? ( d1 ) : ( d2 )) ;    food_(&d__1);// FFEINTRIN_impDMIN1 //    d__1 = (( d1 ) <= ( d2 ) ? ( d1 ) : ( d2 )) ;    food_(&d__1);// FFEINTRIN_impDMOD //    d__1 = d_mod(&d1, &d2);    food_(&d__1);// FFEINTRIN_impDNINT //    d__1 = d_nint(&d1);    food_(&d__1);// FFEINTRIN_impDPROD //    d__1 = (doublereal) r1 * r2;    food_(&d__1);// FFEINTRIN_impDSIGN //    d__1 = d_sign(&d1, &d2);    food_(&d__1);// FFEINTRIN_impDSIN //    d__1 = sin(d1);    food_(&d__1);// FFEINTRIN_impDSINH //    d__1 = sinh(d1);    food_(&d__1);// FFEINTRIN_impDSQRT //    d__1 = sqrt(d1);    food_(&d__1);// FFEINTRIN_impDTAN //    d__1 = tan(d1);    food_(&d__1);// FFEINTRIN_impDTANH //    d__1 = tanh(d1);    food_(&d__1);// FFEINTRIN_impEXP //    r__1 = exp(r1);    foor_(&r__1);// FFEINTRIN_impIABS //    i__1 = (( i1 ) >= 0 ? ( i1 ) : -( i1 )) ;    fooi_(&i__1);// FFEINTRIN_impICHAR //    i__1 = *(unsigned char *)a1;    fooi_(&i__1);// FFEINTRIN_impIDIM //    i__1 = i_dim(&i1, &i2);    fooi_(&i__1);// FFEINTRIN_impIDNINT //    i__1 = i_dnnt(&d1);    fooi_(&i__1);// FFEINTRIN_impINDEX //    i__1 = i_indx(a1, a2, 10L, 10L);    fooi_(&i__1);// FFEINTRIN_impISIGN //    i__1 = i_sign(&i1, &i2);    fooi_(&i__1);// FFEINTRIN_impLEN //    i__1 = i_len(a1, 10L);    fooi_(&i__1);// FFEINTRIN_impLGE //    L__1 = l_ge(a1, a2, 10L, 10L);    fool_(&L__1);// FFEINTRIN_impLGT //    L__1 = l_gt(a1, a2, 10L, 10L);    fool_(&L__1);// FFEINTRIN_impLLE //    L__1 = l_le(a1, a2, 10L, 10L);    fool_(&L__1);// FFEINTRIN_impLLT //    L__1 = l_lt(a1, a2, 10L, 10L);    fool_(&L__1);// FFEINTRIN_impMAX0 //    i__1 = (( i1 ) >= ( i2 ) ? ( i1 ) : ( i2 )) ;    fooi_(&i__1);// FFEINTRIN_impMAX1 //    i__1 = (integer) (doublereal)((  r1  ) >= (  r2  ) ? (  r1  ) : (  r2  ))  ;    fooi_(&i__1);// FFEINTRIN_impMIN0 //    i__1 = (( i1 ) <= ( i2 ) ? ( i1 ) : ( i2 )) ;    fooi_(&i__1);// FFEINTRIN_impMIN1 //    i__1 = (integer) (doublereal)((  r1  ) <= (  r2  ) ? (  r1  ) : (  r2  ))  ;    fooi_(&i__1);// FFEINTRIN_impMOD //    i__1 = i1 % i2;    fooi_(&i__1);// FFEINTRIN_impNINT //    i__1 = i_nint(&r1);    fooi_(&i__1);// FFEINTRIN_impSIGN //    r__1 = r_sign(&r1, &r2);    foor_(&r__1);// FFEINTRIN_impSIN //    r__1 = sin(r1);    foor_(&r__1);// FFEINTRIN_impSINH //    r__1 = sinh(r1);    foor_(&r__1);// FFEINTRIN_impSQRT //    r__1 = sqrt(r1);    foor_(&r__1);// FFEINTRIN_impTAN //    r__1 = tan(r1);    foor_(&r__1);// FFEINTRIN_impTANH //    r__1 = tanh(r1);    foor_(&r__1);// FFEINTRIN_imp_CMPLX_C //    r__1 = c1.r;    r__2 = c2.r;    q__1.r = r__1, q__1.i = r__2;    fooc_(&q__1);// FFEINTRIN_imp_CMPLX_D //    z__1.r = d1, z__1.i = d2;    fooz_(&z__1);// FFEINTRIN_imp_CMPLX_I //    r__1 = (real) i1;    r__2 = (real) i2;    q__1.r = r__1, q__1.i = r__2;    fooc_(&q__1);// FFEINTRIN_imp_CMPLX_R //    q__1.r = r1, q__1.i = r2;    fooc_(&q__1);// FFEINTRIN_imp_DBLE_C //    d__1 = (doublereal) c1.r;    food_(&d__1);// FFEINTRIN_imp_DBLE_D //    d__1 = d1;    food_(&d__1);// FFEINTRIN_imp_DBLE_I //    d__1 = (doublereal) i1;    food_(&d__1);// FFEINTRIN_imp_DBLE_R //    d__1 = (doublereal) r1;    food_(&d__1);// FFEINTRIN_imp_INT_C //    i__1 = (integer) c1.r;    fooi_(&i__1);// FFEINTRIN_imp_INT_D //    i__1 = (integer) d1;    fooi_(&i__1);// FFEINTRIN_imp_INT_I //    i__1 = i1;    fooi_(&i__1);// FFEINTRIN_imp_INT_R //    i__1 = (integer) r1;    fooi_(&i__1);// FFEINTRIN_imp_REAL_C //    r__1 = c1.r;    foor_(&r__1);// FFEINTRIN_imp_REAL_D //    r__1 = (real) d1;    foor_(&r__1);// FFEINTRIN_imp_REAL_I //    r__1 = (real) i1;    foor_(&r__1);// FFEINTRIN_imp_REAL_R //    r__1 = r1;    foor_(&r__1);// FFEINTRIN_imp_INT_D: //// FFEINTRIN_specIDINT //    i__1 = (integer) d1;    fooi_(&i__1);// FFEINTRIN_imp_INT_R: //// FFEINTRIN_specIFIX //    i__1 = (integer) r1;    fooi_(&i__1);// FFEINTRIN_specINT //    i__1 = (integer) r1;    fooi_(&i__1);// FFEINTRIN_imp_REAL_D: //// FFEINTRIN_specSNGL //    r__1 = (real) d1;    foor_(&r__1);// FFEINTRIN_imp_REAL_I: //// FFEINTRIN_specFLOAT //    r__1 = (real) i1;    foor_(&r__1);// FFEINTRIN_specREAL //    r__1 = (real) i1;    foor_(&r__1);} // MAIN__ //-------- (end output file from f2c)*/}