Symbol* tsym1 = NewTemporaryVar (stmt->symbol()->type, "");
                Symbol* tsym2 = NewTemporaryVar (stmt->symbol()->type, "");

                string* x1=new string("0");
                Expression* e01=parser->make_float_const(parser->global_float, x1);
                Expression* e02=DuplicateExpr(ex3);
                Expression* e03=parser->intrinsic_op_node(".lt.", LT_OP, e02, e01);

                Statement* s1=parser->make_stmt(IF_NODE, 0, e03, 0, 0);

                Statement* s1a=NULL;
                Statement* s1b=NULL;
                Statement* s2a=NULL;
                Statement* s2b=NULL;

                {
                  Expression* ee1;

                  if (ex2const)
                  {
                    double var;
                    var=param;
                    if (ex2val>var) var=ex2val; //min

                    sprintf(buf, "%g", var);
                    string* x2=new string(buf);

                    ee1=parser->make_float_const(parser->global_float, x2);
                  }
                  else
                  {
                    sprintf(buf, "%g", param);
                    string* x2=new string(buf);

                    Expression* ex01=parser->make_float_const(parser->global_float, x2);
                    Expression* ex02=DuplicateExpr(ex2);
 
                    Expression* ex03=parser->set_ll_list (ex02, 0, EXPR_LIST);
 
                    Expression* ex04=parser->set_ll_list (ex03, ex01, EXPR_LIST);
                    Symbol* sm01=(parser->global_scope()->look_up_ftn_sym("max"))->symbol();
                    Expression* ex05=parser->make_expr (FUNC_CALL, ex04, 0, sm01);
      
                    ee1=ex05;
                  }

                  Expression* e01=parser->make_expr(VAR_REF, 0, 0, tsym1);

                  s1a=parser->make_stmt(ASSIGN_STAT, 0, e01, ee1, 0);
                }

                {
                  Expression* ee1;

                  sprintf(buf, "%g", param);
                  string* x1=new string(buf);

                  Expression* ex01=parser->make_float_const(parser->global_float, x1);
                  Expression* ex02=DuplicateExpr(ex1);
                  Expression* ex03=parser->intrinsic_op_node("-", SUBT_OP, ex01, ex02);

                  Expression* ex03x1=DuplicateExpr(ex3);
                  Expression* ex03x2=parser->intrinsic_op_node("/", DIV_OP, ex03, ex03x1);

                  string* x3=new string("1");
                  Expression* ex03x3=parser->make_float_const(parser->global_float, x3);
                  Expression* ex03x4=parser->intrinsic_op_node("+", ADD_OP, ex03x2, ex03x3);

                  Expression* ex03a=parser->set_ll_list (ex03x4, 0, EXPR_LIST);

                  Symbol* sm01=(parser->global_scope()->look_up_ftn_sym("int"))->symbol();
                  Expression* ex04=parser->make_expr (FUNC_CALL, ex03a, 0, sm01);

                  Expression* ex03x5=DuplicateExpr(ex3);
                  Expression* ex03x6=parser->intrinsic_op_node("*", MULT_OP, ex04, ex03x5);

                  Expression* ex03x7=DuplicateExpr(ex1);
                  Expression* ex03x8=parser->intrinsic_op_node("+", ADD_OP, ex03x6, ex03x7);

                  Expression* ex03x9=parser->set_ll_list (ex03x8, 0, EXPR_LIST);

                  Expression* ex08=DuplicateExpr(ex1);
                  Expression* ex09=parser->set_ll_list (ex08, ex03x9, EXPR_LIST);
                  Symbol* sm02=(parser->global_scope()->look_up_ftn_sym("min"))->symbol();
                  Expression* ex10=parser->make_expr (FUNC_CALL, ex09, 0, sm02);
 
                  ee1=ex10;

                  Expression* e01=parser->make_expr (VAR_REF, 0, 0, tsym2);

                  s1b=parser->make_stmt(ASSIGN_STAT, 0, e01, ee1, 0);
                }

                Statement* s1c=parser->make_stmt(CONTROL_END, 0, 0, 0, 0);

                {
                  Expression* ee2;

                  if (ex2const)
                  {
                    double var;
                    var=param;
                    if (ex2valmake_float_const(parser->global_float, x2);
                  }
                  else
                  {
                    sprintf(buf, "%g", param);
                    string* x2=new string(buf);

                    Expression* ex01=parser->make_float_const(parser->global_float, x2);
                    Expression* ex02=DuplicateExpr(ex2);
 
                    Expression* ex03=parser->set_ll_list (ex02, 0, EXPR_LIST);
 
                    Expression* ex04=parser->set_ll_list (ex03, ex01, EXPR_LIST);
                    Symbol* sm01=(parser->global_scope()->look_up_ftn_sym("min"))->symbol();
                    Expression* ex05=parser->make_expr (FUNC_CALL, ex04, 0, sm01);
      
                    ee2=ex05;
                  }

                  Expression* e02=parser->make_expr (VAR_REF, 0, 0, tsym1);

                  s2a=parser->make_stmt(ASSIGN_STAT, 0, e02, ee2, 0);
                }

                {
                  Expression* ee2;

                  sprintf(buf, "%g", param);
                  string* x1=new string(buf);

                  Expression* ex01=parser->make_float_const(parser->global_float, x1);
                  Expression* ex02=DuplicateExpr(ex1);
                  Expression* ex03=parser->intrinsic_op_node("-", SUBT_OP, ex01, ex02);

                  Expression* ex03x1=DuplicateExpr(ex3);
                  Expression* ex03x2=parser->intrinsic_op_node("/", DIV_OP, ex03, ex03x1);

                  string* x3=new string("1");
                  Expression* ex03x3=parser->make_float_const(parser->global_float, x3);
                  Expression* ex03x4=parser->intrinsic_op_node("+", ADD_OP, ex03x2, ex03x3);

                  Expression* ex03a=parser->set_ll_list (ex03x4, 0, EXPR_LIST);

                  Symbol* sm01=(parser->global_scope()->look_up_ftn_sym("int"))->symbol();
                  Expression* ex04=parser->make_expr (FUNC_CALL, ex03a, 0, sm01);

                  Expression* ex03x5=DuplicateExpr(ex3);
                  Expression* ex03x6=parser->intrinsic_op_node("*", MULT_OP, ex04, ex03x5);

                  Expression* ex03x7=DuplicateExpr(ex1);
                  Expression* ex03x8=parser->intrinsic_op_node("+", ADD_OP, ex03x6, ex03x7);

                  Expression* ex03x9=parser->set_ll_list (ex03x8, 0, EXPR_LIST);

                  Expression* ex08=DuplicateExpr(ex1);
                  Expression* ex09=parser->set_ll_list (ex08, ex03x9, EXPR_LIST);
                  Symbol* sm02=(parser->global_scope()->look_up_ftn_sym("max"))->symbol();
                  Expression* ex10=parser->make_expr (FUNC_CALL, ex09, 0, sm02);
  
                  ee2=ex10;

                  Expression* e02=parser->make_expr (VAR_REF, 0, 0, tsym2);

                  s2b=parser->make_stmt(ASSIGN_STAT, 0, e02, ee2, 0);
                }

                Statement* s2c=parser->make_stmt(CONTROL_END, 0, 0, 0, 0);

                StmtList* sl1=new StmtList();
                StmtListIterator next_newstmt1(sl1);

                next_newstmt1.insert (s1a, s1) ;
                next_newstmt1.insert (s1b, s1) ;
                next_newstmt1.insert (s1c, s1) ;

                s1->node.fields.bl_ptr1=sl1;

                StmtList* sl2=new StmtList();
                StmtListIterator next_newstmt2(sl2);

                next_newstmt2.insert (s2a, s1) ;
                next_newstmt2.insert (s2b, s1) ;
                next_newstmt2.insert (s2c, s1) ;

                s1->node.fields.bl_ptr2=sl2;

                next_stmt.insert (s1, currentCP) ;

                nexpr2=parser->make_expr (VAR_REF, 0, 0, tsym1);
                nexpr1=parser->make_expr (VAR_REF, 0, 0, tsym2);