nameExpr is g
decl is g: function
  with parameters
    unsigned int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 


decl is g: function
  with parameters
    signed int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          unsigned int 
        returning 
          nothing 

)
Environment: 

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

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

)
Environment: 

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

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

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

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is b
decl is b: float 
newExpr is Variable Expression: b: float 

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

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

Cost ( 0, 0, 0 ): Variable Expression: b: 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 ): Comma Expression:
  Variable Expression: a: signed int 

  Variable Expression: b: signed int 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Comma Expression:
  Variable Expression: a: signed int 

  Variable Expression: b: float 
(types:
    lvalue float 
)
Environment: 

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

  Variable Expression: b: signed int 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Comma Expression:
  Variable Expression: a: signed int 

  Variable Expression: b: float 
(types:
    lvalue float 
)
Environment: 

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

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

)
        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: g: function
            with parameters
              unsigned int 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  unsigned int 
                returning 
                  nothing 

)
        Environment: 
formal type is unsigned 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 unsigned int 
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:
        Comma Expression:
          Variable Expression: a: signed int 

          Variable Expression: b: 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:
                  Comma Expression:
            Variable Expression: a: signed int 

            Variable Expression: b: signed int 

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

          Variable Expression: b: 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:
            Comma Expression:
              Variable Expression: a: signed int 

              Variable Expression: b: float 

          to:
            signed int 

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

          Variable Expression: b: signed int 
--- results are
        lvalue signed int 

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

              Variable Expression: b: signed int 

          to:
            unsigned int 

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

          Variable Expression: b: float 
--- results are
        lvalue float 

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

              Variable Expression: b: float 

          to:
            unsigned int 

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

to arguments
      Comma Expression:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
)
Environment: 

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

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

        Variable Expression: b: float 

    to:
      signed int 

(types:
)
Environment: 

Cost ( 0, 0, 1 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

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

        Variable Expression: b: signed int 

    to:
      unsigned int 

(types:
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

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

        Variable Expression: b: float 

    to:
      unsigned int 

(types:
)
Environment: 

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

  to arguments
          Comma Expression:
        Variable Expression: a: signed int 

        Variable Expression: b: signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is g
decl is g: function
  with parameters
    unsigned int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 


decl is g: function
  with parameters
    signed int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          unsigned int 
        returning 
          nothing 

)
Environment: 

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

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

)
Environment: 

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

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

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

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is a
decl is a: signed int 
newExpr is Variable Expression: a: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Comma Expression:
  Variable Expression: a: signed int 

  Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

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

    Variable Expression: a: signed int 

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is b
decl is b: float 
newExpr is Variable Expression: b: float 

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

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

Cost ( 0, 0, 0 ): Variable Expression: b: 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 ): Comma Expression:
  Comma Expression:
    Variable Expression: a: signed int 

    Variable Expression: a: signed int 

  Variable Expression: b: signed int 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Comma Expression:
  Comma Expression:
    Variable Expression: a: signed int 

    Variable Expression: a: signed int 

  Variable Expression: b: float 
(types:
    lvalue float 
)
Environment: 

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

    Variable Expression: a: signed int 

  Variable Expression: b: signed int 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Comma Expression:
  Comma Expression:
    Variable Expression: a: signed int 

    Variable Expression: a: signed int 

  Variable Expression: b: float 
(types:
    lvalue float 
)
Environment: 

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

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

)
        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: g: function
            with parameters
              unsigned int 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  unsigned int 
                returning 
                  nothing 

)
        Environment: 
formal type is unsigned 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 unsigned int 
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:
        Comma Expression:
          Comma Expression:
            Variable Expression: a: signed int 

            Variable Expression: a: signed int 

          Variable Expression: b: 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:
                  Comma Expression:
            Comma Expression:
              Variable Expression: a: signed int 

              Variable Expression: a: signed int 

            Variable Expression: b: signed int 

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

            Variable Expression: a: signed int 

          Variable Expression: b: 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:
            Comma Expression:
              Comma Expression:
                Variable Expression: a: signed int 

                Variable Expression: a: signed int 

              Variable Expression: b: float 

          to:
            signed int 

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

            Variable Expression: a: signed int 

          Variable Expression: b: signed int 
--- results are
        lvalue signed int 

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

                Variable Expression: a: signed int 

              Variable Expression: b: signed int 

          to:
            unsigned int 

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

            Variable Expression: a: signed int 

          Variable Expression: b: float 
--- results are
        lvalue float 

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

                Variable Expression: a: signed int 

              Variable Expression: b: float 

          to:
            unsigned int 

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

to arguments
      Comma Expression:
      Comma Expression:
        Variable Expression: a: signed int 

        Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
)
Environment: 

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

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

          Variable Expression: a: signed int 

        Variable Expression: b: float 

    to:
      signed int 

(types:
)
Environment: 

Cost ( 0, 0, 1 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

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

          Variable Expression: a: signed int 

        Variable Expression: b: signed int 

    to:
      unsigned int 

(types:
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

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

          Variable Expression: a: signed int 

        Variable Expression: b: float 

    to:
      unsigned int 

(types:
)
Environment: 

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

  to arguments
          Comma Expression:
        Comma Expression:
          Variable Expression: a: signed int 

          Variable Expression: a: signed int 

        Variable Expression: b: signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is g
decl is g: function
  with parameters
    unsigned int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 


decl is g: function
  with parameters
    signed int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          unsigned int 
        returning 
          nothing 

)
Environment: 

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

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

)
Environment: 

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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Sizeof Expression on:   Variable Expression: a: signed int 

(types:
    unsigned int 
)
Environment: 

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

(types:
    unsigned int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is unsigned 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: g: function
            with parameters
              unsigned int 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  unsigned int 
                returning 
                  nothing 

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

--- results are
        unsigned int 

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


          to:
            signed int 

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

--- results are
        unsigned int 

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


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

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


    to:
      signed int 

(types:
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

to arguments
      Sizeof Expression on:       Variable Expression: a: signed int 


(types:
)
Environment: 

cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Application of
    Variable Expression: g: function
        with parameters
          unsigned int 
        returning 
          nothing 

  to arguments
          Sizeof Expression on:         Variable Expression: a: signed int 



to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is g
decl is g: function
  with parameters
    unsigned int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 


decl is g: function
  with parameters
    signed int 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: g: function
    with parameters
      unsigned int 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          unsigned int 
        returning 
          nothing 

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Sizeof Expression on: signed int 
(types:
    unsigned int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Sizeof Expression on: signed int 
(types:
    unsigned int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is unsigned 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: g: function
            with parameters
              unsigned int 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  unsigned int 
                returning 
                  nothing 

)
        Environment: 
formal type is unsigned int 
actual type is unsigned int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Sizeof Expression on: signed int 
--- results are
        unsigned int 

converting unsigned int 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Sizeof Expression on: signed int 

          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Sizeof Expression on: signed int 
--- results are
        unsigned int 

converting unsigned int 
 to unsigned int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        unsigned int 
actuals are:
                  Sizeof Expression on: signed int 

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

to arguments
      Cast of:
      Sizeof Expression on: signed int 

    to:
      signed int 

(types:
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        unsigned int 
      returning 
        nothing 

to arguments
      Sizeof Expression on: signed int 

(types:
)
Environment: 

cost ( 0, 0, 0 ) beats ( 1, 0, 0 )
there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Application of
    Variable Expression: g: function
        with parameters
          unsigned int 
        returning 
          nothing 

  to arguments
          Sizeof Expression on: signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
int __a__i;
int __b__i;
float __b__f;
void __g__F_i_(int );
void __g__F_Ui_(unsigned int );
void __f__F__(void){
    __g__F_i_((__a__i , __b__i));
    __g__F_i_(((__a__i , __a__i) , __b__i));
    __g__F_Ui_(sizeof(__a__i));
    __g__F_Ui_(sizeof(int ));
}