nameExpr is f
decl is f: function
  with parameters
    float 
  returning 
    float 

newExpr is Variable Expression: f: function
    with parameters
      float 
    returning 
      float 


decl is f: function
  with parameters
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: f: function
    with parameters
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: f: function
    with parameters
      float 
    returning 
      float 

(types:
    pointer to function
        with parameters
          float 
        returning 
          float 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: f: function
    with parameters
      signed int 
    returning 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
        returning 
          signed int 

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is a
decl is a: float 
newExpr is Variable Expression: a: float 

decl is a: signed int 
newExpr is Variable Expression: a: signed int 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: float 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Variable Expression: a: signed int 

to:
  signed int 
(types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Cast of:
  Variable Expression: a: signed int 

to:
  signed int 
(types:
    signed int 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: f: function
            with parameters
              signed int 
            returning 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                returning 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: f: function
            with parameters
              float 
            returning 
              float 

(types:
            pointer to function
                with parameters
                  float 
                returning 
                  float 

)
        Environment: 
formal type is float 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Cast of:
          Variable Expression: a: signed int 

        to:
          signed int 
--- results are
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Variable Expression: a: signed int 

          to:
            signed int 

bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Cast of:
          Variable Expression: a: signed int 

        to:
          signed int 
--- results are
        signed int 

converting signed int 
 to float 
cost is( 0, 0, 5 )
Case +++++++++++++
formals are:
        float 
actuals are:
                  Cast of:
            Cast of:
              Variable Expression: a: signed int 

            to:
              signed int 

          to:
            float 

bindings are:
cost of conversion is:( 0, 0, 5 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: f: function
      with parameters
        signed int 
      returning 
        signed int 

to arguments
      Cast of:
      Variable Expression: a: signed int 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 5 ): Application of
  Variable Expression: f: function
      with parameters
        float 
      returning 
        float 

to arguments
      Cast of:
      Cast of:
        Variable Expression: a: signed int 

      to:
        signed int 

    to:
      float 

(types:
    float 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 1 ): Cast of:
  Application of
    Variable Expression: f: function
        with parameters
          signed int 
        returning 
          signed int 

  to arguments
          Cast of:
        Variable Expression: a: signed int 

      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is f
decl is f: function
  with parameters
    float 
  returning 
    float 

newExpr is Variable Expression: f: function
    with parameters
      float 
    returning 
      float 


decl is f: function
  with parameters
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: f: function
    with parameters
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: f: function
    with parameters
      float 
    returning 
      float 

(types:
    pointer to function
        with parameters
          float 
        returning 
          float 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: f: function
    with parameters
      signed int 
    returning 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
        returning 
          signed int 

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is a
decl is a: float 
newExpr is Variable Expression: a: float 

decl is a: signed int 
newExpr is Variable Expression: a: signed int 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: float 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: a: float 
(types:
    lvalue float 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: f: function
            with parameters
              signed int 
            returning 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                returning 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: f: function
            with parameters
              float 
            returning 
              float 

(types:
            pointer to function
                with parameters
                  float 
                returning 
                  float 

)
        Environment: 
formal type is float 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is float 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: a: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Variable Expression: a: signed int 

bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Variable Expression: a: float 
--- results are
        lvalue float 

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Variable Expression: a: float 

          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Variable Expression: a: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to float 
cost is( 0, 0, 5 )
Case +++++++++++++
formals are:
        float 
actuals are:
                  Cast of:
            Variable Expression: a: signed int 

          to:
            float 

bindings are:
cost of conversion is:( 0, 0, 5 )
actual expression:
        Variable Expression: a: float 
--- results are
        lvalue float 

converting lvalue float 
 to float 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        float 
actuals are:
                  Variable Expression: a: float 

bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: f: function
      with parameters
        signed int 
      returning 
        signed int 

to arguments
      Variable Expression: a: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: f: function
      with parameters
        signed int 
      returning 
        signed int 

to arguments
      Cast of:
      Variable Expression: a: float 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 5 ): Application of
  Variable Expression: f: function
      with parameters
        float 
      returning 
        float 

to arguments
      Cast of:
      Variable Expression: a: signed int 

    to:
      float 

(types:
    float 
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: f: function
      with parameters
        float 
      returning 
        float 

to arguments
      Variable Expression: a: float 

(types:
    float 
)
Environment: 

cost ( 0, 0, 0 ) beats ( 0, 0, 5 )
there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Application of
    Variable Expression: f: function
        with parameters
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 


to:
  signed int 
(types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 1 ): Cast of:
  Cast of:
    Application of
      Variable Expression: f: function
          with parameters
            signed int 
          returning 
            signed int 

    to arguments
              Variable Expression: a: signed int 


  to:
    signed int 

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is r
decl is r: function
  with parameters
    signed int 
    signed int 
    signed int 
    signed int 
  returning 
    signed int 
    signed int 

newExpr is Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is p
decl is p: tuple of types
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 


decl is p: tuple of types
  signed int 
  double 

newExpr is Variable Expression: p: tuple of types
    signed int 
    double 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

nameExpr is q
decl is q: tuple of types
  char 

newExpr is Variable Expression: q: tuple of types
    char 


decl is q: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 


decl is q: tuple of types
  signed int 
  signed int 
  float 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 


decl is q: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
actual expression:
        Variable Expression: p: tuple of types
            signed int 

--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 
            float 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue float 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: p: tuple of types
              signed int 


                  Cast of:
            Variable Expression: q: tuple of types
                signed int 
                signed int 
                float 


          to:
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Variable Expression: p: tuple of types
            signed int 
            double 

--- results are
        lvalue signed int 
        lvalue double 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue double 
 to signed int 
cost is( 1, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Variable Expression: p: tuple of types
                signed int 
                double 


          to:
            signed int 
            signed int 

                  Variable Expression: q: tuple of types
              signed int 
              signed int 


bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Variable Expression: p: tuple of types
            signed int 
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            char 

--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: p: tuple of types
              signed int 
              signed int 
              signed int 


                  Cast of:
            Variable Expression: q: tuple of types
                char 


          to:
            signed int 

bindings are:
cost of conversion is:( 0, 0, 4 )
alternatives before prune:
Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: p: tuple of types
        signed int 


      Cast of:
      Variable Expression: q: tuple of types
          signed int 
          signed int 
          float 


    to:
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Variable Expression: p: tuple of types
          signed int 
          double 


    to:
      signed int 
      signed int 

      Variable Expression: q: tuple of types
        signed int 
        signed int 


(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 0, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


      Cast of:
      Variable Expression: q: tuple of types
          char 


    to:
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

marking ambiguous
cost ( 0, 0, 4 ) beats ( 1, 0, 0 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 2 ): Cast of:
  Application of
    Variable Expression: r: function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

  to arguments
          Variable Expression: p: tuple of types
          signed int 
          signed int 
          signed int 


          Cast of:
        Variable Expression: q: tuple of types
            char 


      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is r
decl is r: function
  with parameters
    signed int 
    signed int 
    signed int 
    signed int 
  returning 
    signed int 
    signed int 

newExpr is Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is q
decl is q: tuple of types
  char 

newExpr is Variable Expression: q: tuple of types
    char 


decl is q: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 


decl is q: tuple of types
  signed int 
  signed int 
  float 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 


decl is q: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

nameExpr is p
decl is p: tuple of types
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 


decl is p: tuple of types
  signed int 
  double 

newExpr is Variable Expression: p: tuple of types
    signed int 
    double 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue char 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue char 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue char 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue char 
    lvalue signed int 
)
Environment: 

marking ambiguous
there are 15 alternatives before elimination
there are 14 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        signed int 
        signed int 
        float 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 
        signed int 


(types:
    lvalue char 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


(types:
    lvalue char 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 
        double 


(types:
    lvalue char 
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: q: tuple of types
        char 


      Variable Expression: p: tuple of types
        signed int 


(types:
    lvalue char 
    lvalue signed int 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
actual expression:
        Tuple:
                      Variable Expression: q: tuple of types
                signed int 
                signed int 


                      Variable Expression: p: tuple of types
                signed int 
                double 


--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue signed int 
        lvalue double 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue double 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Tuple:
                              Variable Expression: q: tuple of types
                    signed int 
                    signed int 


                              Variable Expression: p: tuple of types
                    signed int 
                    double 



          to:
            signed int 
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Tuple:
                      Variable Expression: q: tuple of types
                signed int 
                signed int 
                float 


                      Variable Expression: p: tuple of types
                signed int 


--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue float 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Tuple:
                              Variable Expression: q: tuple of types
                    signed int 
                    signed int 
                    float 


                              Variable Expression: p: tuple of types
                    signed int 



          to:
            signed int 
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Tuple:
                      Variable Expression: q: tuple of types
                char 


                      Variable Expression: p: tuple of types
                signed int 
                signed int 
                signed int 


--- results are
        lvalue char 
        lvalue signed int 
        lvalue signed int 
        lvalue signed int 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Tuple:
                              Variable Expression: q: tuple of types
                    char 


                              Variable Expression: p: tuple of types
                    signed int 
                    signed int 
                    signed int 



          to:
            signed int 
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 0, 0, 4 )
alternatives before prune:
Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Tuple:
                  Variable Expression: q: tuple of types
              signed int 
              signed int 


                  Variable Expression: p: tuple of types
              signed int 
              double 



    to:
      signed int 
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Tuple:
                  Variable Expression: q: tuple of types
              signed int 
              signed int 
              float 


                  Variable Expression: p: tuple of types
              signed int 



    to:
      signed int 
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 0, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Tuple:
                  Variable Expression: q: tuple of types
              char 


                  Variable Expression: p: tuple of types
              signed int 
              signed int 
              signed int 



    to:
      signed int 
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

marking ambiguous
cost ( 0, 0, 4 ) beats ( 1, 0, 0 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 2 ): Cast of:
  Application of
    Variable Expression: r: function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

  to arguments
          Cast of:
        Tuple:
                      Variable Expression: q: tuple of types
                char 


                      Variable Expression: p: tuple of types
                signed int 
                signed int 
                signed int 



      to:
        signed int 
        signed int 
        signed int 
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is r
decl is r: function
  with parameters
    signed int 
    signed int 
    signed int 
    signed int 
  returning 
    signed int 
    signed int 

newExpr is Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is r
decl is r: function
  with parameters
    signed int 
    signed int 
    signed int 
    signed int 
  returning 
    signed int 
    signed int 

newExpr is Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is p
decl is p: tuple of types
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 


decl is p: tuple of types
  signed int 
  double 

newExpr is Variable Expression: p: tuple of types
    signed int 
    double 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 


decl is p: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 
    double 

(types:
    lvalue signed int 
    lvalue double 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: p: tuple of types
    signed int 

(types:
    lvalue signed int 
)
Environment: 

nameExpr is q
decl is q: tuple of types
  char 

newExpr is Variable Expression: q: tuple of types
    char 


decl is q: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 


decl is q: tuple of types
  signed int 
  signed int 
  float 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 


decl is q: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue double 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
actual expression:
        Variable Expression: p: tuple of types
            signed int 

--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 
            float 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue float 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: p: tuple of types
              signed int 


                  Cast of:
            Variable Expression: q: tuple of types
                signed int 
                signed int 
                float 


          to:
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Variable Expression: p: tuple of types
            signed int 
            double 

--- results are
        lvalue signed int 
        lvalue double 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue double 
 to signed int 
cost is( 1, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Variable Expression: p: tuple of types
                signed int 
                double 


          to:
            signed int 
            signed int 

                  Variable Expression: q: tuple of types
              signed int 
              signed int 


bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Variable Expression: p: tuple of types
            signed int 
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            char 

--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: p: tuple of types
              signed int 
              signed int 
              signed int 


                  Cast of:
            Variable Expression: q: tuple of types
                char 


          to:
            signed int 

bindings are:
cost of conversion is:( 0, 0, 4 )
alternatives before prune:
Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: p: tuple of types
        signed int 


      Cast of:
      Variable Expression: q: tuple of types
          signed int 
          signed int 
          float 


    to:
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Variable Expression: p: tuple of types
          signed int 
          double 


    to:
      signed int 
      signed int 

      Variable Expression: q: tuple of types
        signed int 
        signed int 


(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 0, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


      Cast of:
      Variable Expression: q: tuple of types
          char 


    to:
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

marking ambiguous
cost ( 0, 0, 4 ) beats ( 1, 0, 0 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: p: tuple of types
        signed int 
        signed int 
        signed int 


      Cast of:
      Variable Expression: q: tuple of types
          char 


    to:
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

nameExpr is r
decl is r: function
  with parameters
    signed int 
    signed int 
    signed int 
    signed int 
  returning 
    signed int 
    signed int 

newExpr is Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: function
    with parameters
      signed int 
      signed int 
      signed int 
      signed int 
    returning 
      signed int 
      signed int 

(types:
    pointer to function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is q
decl is q: tuple of types
  char 

newExpr is Variable Expression: q: tuple of types
    char 


decl is q: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 


decl is q: tuple of types
  signed int 
  signed int 
  float 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 


decl is q: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

nameExpr is q
decl is q: tuple of types
  char 

newExpr is Variable Expression: q: tuple of types
    char 


decl is q: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 


decl is q: tuple of types
  signed int 
  signed int 
  float 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 


decl is q: tuple of types
  signed int 
  signed int 
  signed int 
  signed int 

newExpr is Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 4 alternatives before elimination
there are 4 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 
    float 

(types:
    lvalue signed int 
    lvalue signed int 
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: q: tuple of types
    char 

(types:
    lvalue char 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue float 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue char 
actual expression:
        Variable Expression: q: tuple of types
            char 

--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 
            float 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue float 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Variable Expression: q: tuple of types
                char 


          to:
            signed int 

                  Cast of:
            Variable Expression: q: tuple of types
                signed int 
                signed int 
                float 


          to:
            signed int 
            signed int 
            signed int 

bindings are:
cost of conversion is:( 1, 0, 4 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: q: tuple of types
              signed int 
              signed int 


                  Variable Expression: q: tuple of types
              signed int 
              signed int 


bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            signed int 
            signed int 
            float 

--- results are
        lvalue signed int 
        lvalue signed int 
        lvalue float 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
actual expression:
        Variable Expression: q: tuple of types
            char 

--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Cast of:
            Variable Expression: q: tuple of types
                signed int 
                signed int 
                float 


          to:
            signed int 
            signed int 
            signed int 

                  Cast of:
            Variable Expression: q: tuple of types
                char 


          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 4 )
alternatives before prune:
Cost ( 1, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Variable Expression: q: tuple of types
          char 


    to:
      signed int 

      Cast of:
      Variable Expression: q: tuple of types
          signed int 
          signed int 
          float 


    to:
      signed int 
      signed int 
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: q: tuple of types
        signed int 
        signed int 


(types:
    signed int 
    signed int 
)
Environment: 

Cost ( 1, 0, 4 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Cast of:
      Variable Expression: q: tuple of types
          signed int 
          signed int 
          float 


    to:
      signed int 
      signed int 
      signed int 

      Cast of:
      Variable Expression: q: tuple of types
          char 


    to:
      signed int 

(types:
    signed int 
    signed int 
)
Environment: 

cost ( 0, 0, 0 ) beats ( 1, 0, 4 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Variable Expression: q: tuple of types
        signed int 
        signed int 


      Variable Expression: q: tuple of types
        signed int 
        signed int 


(types:
    signed int 
    signed int 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

)
        Environment: 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Application of
          Variable Expression: r: function
              with parameters
                signed int 
                signed int 
                signed int 
                signed int 
              returning 
                signed int 
                signed int 

        to arguments
                      Variable Expression: p: tuple of types
                signed int 
                signed int 
                signed int 


                      Cast of:
              Variable Expression: q: tuple of types
                  char 


            to:
              signed int 

--- results are
        signed int 
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Application of
          Variable Expression: r: function
              with parameters
                signed int 
                signed int 
                signed int 
                signed int 
              returning 
                signed int 
                signed int 

        to arguments
                      Variable Expression: q: tuple of types
                signed int 
                signed int 


                      Variable Expression: q: tuple of types
                signed int 
                signed int 


--- results are
        signed int 
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
        signed int 
actuals are:
                  Application of
            Variable Expression: r: function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

          to arguments
                          Variable Expression: p: tuple of types
                  signed int 
                  signed int 
                  signed int 


                          Cast of:
                Variable Expression: q: tuple of types
                    char 


              to:
                signed int 


                  Application of
            Variable Expression: r: function
                with parameters
                  signed int 
                  signed int 
                  signed int 
                  signed int 
                returning 
                  signed int 
                  signed int 

          to arguments
                          Variable Expression: q: tuple of types
                  signed int 
                  signed int 


                          Variable Expression: q: tuple of types
                  signed int 
                  signed int 



bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: r: function
      with parameters
        signed int 
        signed int 
        signed int 
        signed int 
      returning 
        signed int 
        signed int 

to arguments
      Application of
      Variable Expression: r: function
          with parameters
            signed int 
            signed int 
            signed int 
            signed int 
          returning 
            signed int 
            signed int 

    to arguments
              Variable Expression: p: tuple of types
            signed int 
            signed int 
            signed int 


              Cast of:
          Variable Expression: q: tuple of types
              char 


        to:
          signed int 


      Application of
      Variable Expression: r: function
          with parameters
            signed int 
            signed int 
            signed int 
            signed int 
          returning 
            signed int 
            signed int 

    to arguments
              Variable Expression: q: tuple of types
            signed int 
            signed int 


              Variable Expression: q: tuple of types
            signed int 
            signed int 



(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 2 ): Cast of:
  Application of
    Variable Expression: r: function
        with parameters
          signed int 
          signed int 
          signed int 
          signed int 
        returning 
          signed int 
          signed int 

  to arguments
          Application of
        Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

      to arguments
                  Variable Expression: p: tuple of types
              signed int 
              signed int 
              signed int 


                  Cast of:
            Variable Expression: q: tuple of types
                char 


          to:
            signed int 


          Application of
        Variable Expression: r: function
            with parameters
              signed int 
              signed int 
              signed int 
              signed int 
            returning 
              signed int 
              signed int 

      to arguments
                  Variable Expression: q: tuple of types
              signed int 
              signed int 


                  Variable Expression: q: tuple of types
              signed int 
              signed int 




to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
cfa-cpp: GenPoly/Box.cc:401: void GenPoly::{anonymous}::Pass1::boxParams(ApplicationExpr*, FunctionType*, std::list<Expression*>::iterator&, const TyVarMap&): Assertion `arg != appExpr->get_args().end()' failed.
Aborted (core dumped)
