nameExpr is g
decl is g: function
  with parameters
    float 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      float 
    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
      float 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          float 
        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 ?!=?
decl is ?!=?: function
  with parameters
    float 
    float 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 


decl is ?!=?: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 

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

)
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
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

nameExpr is 0
decl is 0: signed int 
newExpr is Variable Expression: 0: signed int 

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

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

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

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                returning 
                  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 
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: ?!=?: function
            with parameters
              float 
              float 
            returning 
              signed int 

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

)
        Environment: 
formal type is float 
actual type is lvalue signed int 
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===
actual expression:
        Variable Expression: a: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

                  Variable Expression: 0: signed int 

bindings are:
cost of conversion is:( 0, 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 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

          to:
            float 

                  Cast of:
            Variable Expression: 0: signed int 

          to:
            float 

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

to arguments
      Variable Expression: a: signed int 

      Variable Expression: 0: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 10 ): Application of
  Variable Expression: ?!=?: function
      with parameters
        float 
        float 
      returning 
        signed int 

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

    to:
      float 

      Cast of:
      Variable Expression: 0: signed int 

    to:
      float 

(types:
    signed int 
)
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: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


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

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

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

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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
alternatives before prune:
Cost ( 0, 0, 0 ): Conditional expression on: 
  Cast of:
    Application of
      Variable Expression: ?!=?: function
          with parameters
            signed int 
            signed int 
          returning 
            signed int 

    to arguments
              Variable Expression: a: signed int 

              Variable Expression: 0: signed int 


  to:
    signed int 
First alternative:
  Variable Expression: b: signed int 
Second alternative:
  Variable Expression: c: float 

(types:
    lvalue float 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Conditional expression on: 
  Cast of:
    Application of
      Variable Expression: ?!=?: function
          with parameters
            signed int 
            signed int 
          returning 
            signed int 

    to arguments
              Variable Expression: a: signed int 

              Variable Expression: 0: signed int 


  to:
    signed int 
First alternative:
  Variable Expression: b: signed int 
Second alternative:
  Variable Expression: c: 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 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
              float 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  float 
                returning 
                  nothing 

)
        Environment: 
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:
        Conditional expression on: 
          Cast of:
            Application of
              Variable Expression: ?!=?: function
                  with parameters
                    signed int 
                    signed int 
                  returning 
                    signed int 

            to arguments
                              Variable Expression: a: signed int 

                              Variable Expression: 0: signed int 


          to:
            signed int 
        First alternative:
          Variable Expression: b: signed int 
        Second alternative:
          Variable Expression: c: 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:
            Conditional expression on: 
              Cast of:
                Application of
                  Variable Expression: ?!=?: function
                      with parameters
                        signed int 
                        signed int 
                      returning 
                        signed int 

                to arguments
                                      Variable Expression: a: signed int 

                                      Variable Expression: 0: signed int 


              to:
                signed int 
            First alternative:
              Variable Expression: b: signed int 
            Second alternative:
              Variable Expression: c: float 


          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Conditional expression on: 
          Cast of:
            Application of
              Variable Expression: ?!=?: function
                  with parameters
                    signed int 
                    signed int 
                  returning 
                    signed int 

            to arguments
                              Variable Expression: a: signed int 

                              Variable Expression: 0: signed int 


          to:
            signed int 
        First alternative:
          Variable Expression: b: signed int 
        Second alternative:
          Variable Expression: c: float 

--- results are
        lvalue float 

converting lvalue float 
 to float 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        float 
actuals are:
                  Conditional expression on: 
            Cast of:
              Application of
                Variable Expression: ?!=?: function
                    with parameters
                      signed int 
                      signed int 
                    returning 
                      signed int 

              to arguments
                                  Variable Expression: a: signed int 

                                  Variable Expression: 0: signed int 


            to:
              signed int 
          First alternative:
            Variable Expression: b: signed int 
          Second alternative:
            Variable Expression: c: float 


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:
      Conditional expression on: 
        Cast of:
          Application of
            Variable Expression: ?!=?: function
                with parameters
                  signed int 
                  signed int 
                returning 
                  signed int 

          to arguments
                          Variable Expression: a: signed int 

                          Variable Expression: 0: signed int 


        to:
          signed int 
      First alternative:
        Variable Expression: b: signed int 
      Second alternative:
        Variable Expression: c: float 


    to:
      signed int 

(types:
)
Environment: 

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

to arguments
      Conditional expression on: 
      Cast of:
        Application of
          Variable Expression: ?!=?: function
              with parameters
                signed int 
                signed int 
              returning 
                signed int 

        to arguments
                      Variable Expression: a: signed int 

                      Variable Expression: 0: signed int 


      to:
        signed int 
    First alternative:
      Variable Expression: b: signed int 
    Second alternative:
      Variable Expression: c: float 


(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
          float 
        returning 
          nothing 

  to arguments
          Conditional expression on: 
        Cast of:
          Application of
            Variable Expression: ?!=?: function
                with parameters
                  signed int 
                  signed int 
                returning 
                  signed int 

          to arguments
                          Variable Expression: a: signed int 

                          Variable Expression: 0: signed int 


        to:
          signed int 
      First alternative:
        Variable Expression: b: signed int 
      Second alternative:
        Variable Expression: c: float 



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
    float 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      float 
    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
      float 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          float 
        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 ?!=?
decl is ?!=?: function
  with parameters
    float 
    float 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 


decl is ?!=?: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 

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

)
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
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

nameExpr is 0
decl is 0: signed int 
newExpr is Variable Expression: 0: signed int 

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

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

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

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                returning 
                  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 
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: ?!=?: function
            with parameters
              float 
              float 
            returning 
              signed int 

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

)
        Environment: 
formal type is float 
actual type is lvalue signed int 
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===
actual expression:
        Variable Expression: a: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

                  Variable Expression: 0: signed int 

bindings are:
cost of conversion is:( 0, 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 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

          to:
            float 

                  Cast of:
            Variable Expression: 0: signed int 

          to:
            float 

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

to arguments
      Variable Expression: a: signed int 

      Variable Expression: 0: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 10 ): Application of
  Variable Expression: ?!=?: function
      with parameters
        float 
        float 
      returning 
        signed int 

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

    to:
      float 

      Cast of:
      Variable Expression: 0: signed int 

    to:
      float 

(types:
    signed int 
)
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: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?!=?
decl is ?!=?: function
  with parameters
    float 
    float 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 


decl is ?!=?: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 

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

)
Environment: 

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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: c: float 
(types:
    lvalue float 
)
Environment: 

nameExpr is 0
decl is 0: signed int 
newExpr is Variable Expression: 0: signed int 

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

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

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

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

)
        Environment: 
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===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?!=?: function
            with parameters
              float 
              float 
            returning 
              signed int 

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

)
        Environment: 
formal type is float 
actual type is lvalue float 
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===
actual expression:
        Variable Expression: c: float 
--- results are
        lvalue float 

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

          to:
            signed int 

                  Variable Expression: 0: signed int 

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

converting lvalue float 
 to float 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

                  Cast of:
            Variable Expression: 0: signed int 

          to:
            float 

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

to arguments
      Cast of:
      Variable Expression: c: float 

    to:
      signed int 

      Variable Expression: 0: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 5 ): Application of
  Variable Expression: ?!=?: function
      with parameters
        float 
        float 
      returning 
        signed int 

to arguments
      Variable Expression: c: float 

      Cast of:
      Variable Expression: 0: signed int 

    to:
      float 

(types:
    signed int 
)
Environment: 

cost ( 0, 0, 5 ) 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: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


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, 0 ): Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  signed int 

(types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  signed int 

(types:
    signed 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 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: g: function
            with parameters
              float 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  float 
                returning 
                  nothing 

)
        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:
        Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


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:
                  Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  signed int 


bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


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:
            Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


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

to arguments
      Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  signed int 


(types:
)
Environment: 

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

to arguments
      Cast of:
      Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  signed int 


    to:
      float 

(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
          Short-circuited operation (and) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          float 
          float 
        returning 
          signed int 

  to arguments
          Variable Expression: c: float 

          Cast of:
        Variable Expression: 0: signed int 

      to:
        float 


to:
  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
    float 
  returning 
    nothing 

newExpr is Variable Expression: g: function
    with parameters
      float 
    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
      float 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          float 
        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 ?!=?
decl is ?!=?: function
  with parameters
    float 
    float 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 


decl is ?!=?: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 

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

)
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
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: a: signed int 
(types:
    lvalue signed int 
)
Environment: 

nameExpr is 0
decl is 0: signed int 
newExpr is Variable Expression: 0: signed int 

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

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

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

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                returning 
                  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 
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: ?!=?: function
            with parameters
              float 
              float 
            returning 
              signed int 

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

)
        Environment: 
formal type is float 
actual type is lvalue signed int 
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===
actual expression:
        Variable Expression: a: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

                  Variable Expression: 0: signed int 

bindings are:
cost of conversion is:( 0, 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 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

          to:
            float 

                  Cast of:
            Variable Expression: 0: signed int 

          to:
            float 

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

to arguments
      Variable Expression: a: signed int 

      Variable Expression: 0: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 10 ): Application of
  Variable Expression: ?!=?: function
      with parameters
        float 
        float 
      returning 
        signed int 

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

    to:
      float 

      Cast of:
      Variable Expression: 0: signed int 

    to:
      float 

(types:
    signed int 
)
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: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?!=?
decl is ?!=?: function
  with parameters
    float 
    float 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 


decl is ?!=?: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      float 
      float 
    returning 
      signed int 

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?!=?: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 

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

)
Environment: 

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

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

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

nameExpr is 0
decl is 0: signed int 
newExpr is Variable Expression: 0: signed int 

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

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

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

(types:
            pointer to function
                with parameters
                  signed int 
                  signed int 
                returning 
                  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 
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: ?!=?: function
            with parameters
              float 
              float 
            returning 
              signed int 

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

)
        Environment: 
formal type is float 
actual type is lvalue signed int 
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===
actual expression:
        Variable Expression: b: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

                  Variable Expression: 0: signed int 

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

converting lvalue signed int 
 to float 
cost is( 0, 0, 5 )
actual expression:
        Variable Expression: 0: signed int 
--- results are
        lvalue signed int 

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

          to:
            float 

                  Cast of:
            Variable Expression: 0: signed int 

          to:
            float 

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

to arguments
      Variable Expression: b: signed int 

      Variable Expression: 0: signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 10 ): Application of
  Variable Expression: ?!=?: function
      with parameters
        float 
        float 
      returning 
        signed int 

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

    to:
      float 

      Cast of:
      Variable Expression: 0: signed int 

    to:
      float 

(types:
    signed int 
)
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: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: 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, 0 ): Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: 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 ): Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 

(types:
    signed 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 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: g: function
            with parameters
              float 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  float 
                returning 
                  nothing 

)
        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:
        Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: 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:
                  Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 


bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: 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:
            Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: 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: g: function
      with parameters
        signed int 
      returning 
        nothing 

to arguments
      Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 


(types:
)
Environment: 

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

to arguments
      Cast of:
      Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 


    to:
      float 

(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
          Short-circuited operation (or) on: Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: a: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 
 and Cast of:
  Application of
    Variable Expression: ?!=?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: b: signed int 

          Variable Expression: 0: signed int 


to:
  signed int 



to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
int ___operator_notequal__Fi_ii_(int , int );
int ___operator_notequal__Fi_ff_(float , float );
int ___constant_zero__i;
void __g__F_f_(float );
void __g__F_i_(int );
void __f__F_i_(int __a__i){
    int __b__i;
    float __c__f;
    __g__F_f_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) ? __b__i : __c__f));
    __g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) && ((int )___operator_notequal__Fi_ff_(__c__f, ((float )___constant_zero__i)))));
    __g__F_i_((((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i)) || ((int )___operator_notequal__Fi_ii_(__b__i, ___constant_zero__i))));
}
