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)))); }