nameExpr is ?*?
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
      signed int 
      signed int 
    returning 
      signed int 

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

)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: number1: 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: number1: signed int 
(types:
    lvalue signed int 
)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: number2: 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: number2: 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===
actual expression:
        Variable Expression: number1: signed int 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: number2: 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: number1: signed int 

                  Variable Expression: number2: signed int 

bindings are:
cost of conversion is:( 0, 0, 0 )
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: number1: signed int 

      Variable Expression: number2: 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 ): Cast of:
  Application of
    Variable Expression: ?*?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: number1: signed int 

          Variable Expression: number2: 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 ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct accumulator 
    _src: instance of struct accumulator 
  returning 
    instance of struct accumulator 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  total: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct accumulator 
              Member Expression, with field: 
                total: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct accumulator 

              Return Statement, returning: Variable Expression: _src: instance of struct accumulator 



newExpr is Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct accumulator 
      _src: instance of struct accumulator 
    returning 
      instance of struct accumulator 


decl is ?=?: function
  with parameters
    pointer to signed int 
    signed int 
  returning 
    signed int 

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


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct accumulator 
      _src: instance of struct accumulator 
    returning 
      instance of struct accumulator 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of struct accumulator 
          _src: instance of struct accumulator 
        returning 
          instance of struct accumulator 

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  total: signed int 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct accumulator 
(types:
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Member Expression, with field: 
    total: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct accumulator 
(types:
    pointer to signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Member Expression, with field: 
    total: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct accumulator 
(types:
    pointer to signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  total: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct accumulator 
(types:
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  total: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct accumulator 
(types:
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to signed int 
actual type is pointer to 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: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct accumulator 
              _src: instance of struct accumulator 
            returning 
              instance of struct accumulator 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of struct accumulator 
                  _src: instance of struct accumulator 
                returning 
                  instance of struct accumulator 

)
        Environment: 
formal type is pointer to instance of struct accumulator 
actual type is pointer to signed int 
actual expression:
        Address of:
          Member Expression, with field: 
            total: signed int 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct accumulator 
--- results are
        pointer to signed int 

converting pointer to signed int 
 to pointer to signed int 
cost is( 0, 0, 0 )
actual expression:
        Member Expression, with field: 
          total: signed int 
        from aggregate: 
          Variable Expression: _src: instance of struct accumulator 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to signed int 
        signed int 
actuals are:
                  Address of:
            Member Expression, with field: 
              total: signed int 
            from aggregate: 
              Applying untyped: 
                  Name: *?
              ...to: 
                  Variable Expression: _dst: pointer to instance of struct accumulator 

                  Member Expression, with field: 
            total: signed int 
          from aggregate: 
            Variable Expression: _src: instance of struct accumulator 

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

to arguments
      Address of:
      Member Expression, with field: 
        total: signed int 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct accumulator 

      Member Expression, with field: 
      total: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct accumulator 

(types:
    signed int 
)
Environment: 

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

  to arguments
          Address of:
        Member Expression, with field: 
          total: signed int 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct accumulator 

          Member Expression, with field: 
        total: signed int 
      from aggregate: 
        Variable Expression: _src: instance of struct accumulator 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _src: instance of struct accumulator 
(types:
    lvalue instance of struct accumulator 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Variable Expression: _src: instance of struct accumulator 

to:
  instance of struct accumulator 
(types:
    instance of struct accumulator 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?()
decl is ?(): function
  with parameters
    a: instance of struct accumulator 
    number1: char 
    number2: char 
  returning 
    char 

newExpr is Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 


decl is ?(): function
  with parameters
    number1: signed int 
    number2: signed int 
  returning 
    signed int 
  with body 
    CompoundStmt
              Return Statement, returning: Cast of:
  Application of
    Variable Expression: ?*?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: number1: signed int 

          Variable Expression: number2: signed int 


to:
  signed int 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 

(types:
    pointer to function
        with parameters
          a: instance of struct accumulator 
          number1: char 
          number2: char 
        returning 
          char 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 

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

)
Environment: 

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

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

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

nameExpr is b
decl is b: char 
newExpr is Variable Expression: b: char 

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

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

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

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

)
        Environment: 
formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?(): function
            with parameters
              a: instance of struct accumulator 
              number1: char 
              number2: char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  a: instance of struct accumulator 
                  number1: char 
                  number2: char 
                returning 
                  char 

)
        Environment: 
formal type is instance of struct accumulator 
actual type is lvalue char 
actual expression:
        Variable Expression: a: char 
--- results are
        lvalue char 

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

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

          to:
            signed int 

                  Cast of:
            Variable Expression: b: char 

          to:
            signed int 

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

to arguments
      Cast of:
      Variable Expression: a: char 

    to:
      signed int 

      Cast of:
      Variable Expression: b: char 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

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

  to arguments
          Cast of:
        Variable Expression: a: char 

      to:
        signed int 

          Cast of:
        Variable Expression: b: char 

      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

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

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

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

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

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

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: a: char 
(types:
            lvalue char 
)
        Environment: 
nameExpr is ?()
decl is ?(): function
  with parameters
    a: instance of struct accumulator 
    number1: char 
    number2: char 
  returning 
    char 

newExpr is Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 


decl is ?(): function
  with parameters
    number1: signed int 
    number2: signed int 
  returning 
    signed int 
  with body 
    CompoundStmt
              Return Statement, returning: Cast of:
  Application of
    Variable Expression: ?*?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: number1: signed int 

          Variable Expression: number2: signed int 


to:
  signed int 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 

(types:
    pointer to function
        with parameters
          a: instance of struct accumulator 
          number1: char 
          number2: char 
        returning 
          char 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
known function ops:
        Cost ( 0, 0, 0 ):         Variable Expression: ?(): function
            with parameters
              number1: signed int 
              number2: signed int 
            returning 
              signed int 

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

)
        Environment: 

        Cost ( 0, 0, 0 ):         Variable Expression: ?(): function
            with parameters
              a: instance of struct accumulator 
              number1: char 
              number2: char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  a: instance of struct accumulator 
                  number1: char 
                  number2: char 
                returning 
                  char 

)
        Environment: 

formal type is signed int 
actual type is lvalue char 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is instance of struct accumulator 
actual type is lvalue char 
actual expression:
        Variable Expression: a: char 
--- results are
        lvalue char 

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

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

          to:
            signed int 

                  Cast of:
            Variable Expression: b: char 

          to:
            signed int 

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

to arguments
      Cast of:
      Variable Expression: a: char 

    to:
      signed int 

      Cast of:
      Variable Expression: b: char 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

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

  to arguments
          Cast of:
        Variable Expression: a: char 

      to:
        signed int 

          Cast of:
        Variable Expression: b: char 

      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?+?
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
      signed int 
      signed int 
    returning 
      signed int 

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

)
Environment: 

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

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

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

nameExpr is b
decl is b: char 
newExpr is Variable Expression: b: char 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: b: char 
(types:
    lvalue char 
)
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 char 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: a: char 
--- results are
        lvalue char 

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

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

          to:
            signed int 

                  Cast of:
            Variable Expression: b: char 

          to:
            signed int 

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

to arguments
      Cast of:
      Variable Expression: a: char 

    to:
      signed int 

      Cast of:
      Variable Expression: b: char 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

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

  to arguments
          Cast of:
        Variable Expression: a: char 

      to:
        signed int 

          Cast of:
        Variable Expression: b: char 

      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?+?
decl is ?+?: instance of struct accumulator 
newExpr is Variable Expression: ?+?: instance of struct accumulator 

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: ?+?: instance of struct accumulator 
(types:
    lvalue instance of struct accumulator 
)
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: char 
newExpr is Variable Expression: a: char 

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

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

nameExpr is b
decl is b: char 
newExpr is Variable Expression: b: char 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: b: char 
(types:
    lvalue char 
)
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 char 
formal type is signed int 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?+?: instance of struct accumulator 
(types:
            lvalue instance of struct accumulator 
)
        Environment: 
nameExpr is ?()
decl is ?(): function
  with parameters
    a: instance of struct accumulator 
    number1: char 
    number2: char 
  returning 
    char 

newExpr is Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 


decl is ?(): function
  with parameters
    number1: signed int 
    number2: signed int 
  returning 
    signed int 
  with body 
    CompoundStmt
              Return Statement, returning: Cast of:
  Application of
    Variable Expression: ?*?: function
        with parameters
          signed int 
          signed int 
        returning 
          signed int 

  to arguments
          Variable Expression: number1: signed int 

          Variable Expression: number2: signed int 


to:
  signed int 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      a: instance of struct accumulator 
      number1: char 
      number2: char 
    returning 
      char 

(types:
    pointer to function
        with parameters
          a: instance of struct accumulator 
          number1: char 
          number2: char 
        returning 
          char 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?(): function
    with parameters
      number1: signed int 
      number2: signed int 
    returning 
      signed int 

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
known function ops:
        Cost ( 0, 0, 0 ):         Variable Expression: ?(): function
            with parameters
              number1: signed int 
              number2: signed int 
            returning 
              signed int 

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

)
        Environment: 

        Cost ( 0, 0, 0 ):         Variable Expression: ?(): function
            with parameters
              a: instance of struct accumulator 
              number1: char 
              number2: char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  a: instance of struct accumulator 
                  number1: char 
                  number2: char 
                returning 
                  char 

)
        Environment: 

formal type is signed int 
actual type is lvalue instance of struct accumulator 
formal type is instance of struct accumulator 
actual type is lvalue instance of struct accumulator 
formal type is char 
actual type is lvalue char 
formal type is char 
actual type is lvalue char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: a: char 
--- results are
        lvalue char 

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

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

          to:
            signed int 

                  Cast of:
            Variable Expression: b: char 

          to:
            signed int 

bindings are:
cost of conversion is:( 0, 0, 8 )
actual expression:
        Variable Expression: ?+?: instance of struct accumulator 
--- results are
        lvalue instance of struct accumulator 

converting lvalue instance of struct accumulator 
 to instance of struct accumulator 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: a: char 
--- results are
        lvalue char 

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

converting lvalue char 
 to char 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        a: instance of struct accumulator 
        number1: char 
        number2: char 
actuals are:
                  Variable Expression: ?+?: instance of struct accumulator 

                  Variable Expression: a: char 

                  Variable Expression: b: char 

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

to arguments
      Cast of:
      Variable Expression: a: char 

    to:
      signed int 

      Cast of:
      Variable Expression: b: char 

    to:
      signed int 

(types:
    signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: ?(): function
      with parameters
        a: instance of struct accumulator 
        number1: char 
        number2: char 
      returning 
        char 

to arguments
      Variable Expression: ?+?: instance of struct accumulator 

      Variable Expression: a: char 

      Variable Expression: b: char 

(types:
    char 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 1 ): Cast of:
  Application of
    Variable Expression: ?(): function
        with parameters
          a: instance of struct accumulator 
          number1: char 
          number2: char 
        returning 
          char 

  to arguments
          Variable Expression: ?+?: instance of struct accumulator 

          Variable Expression: a: char 

          Variable Expression: b: char 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
int ___operator_multiply__Fi_ii_(int , int );
int ___operator_call__Fi_ii_(int __number1__i, int __number2__i){
    return ___operator_multiply__Fi_ii_(__number1__i, __number2__i);
}
int ___operator_add__Fi_ii_(int , int );
int ___operator_assign__Fi_Pii_(int *, int );
struct accumulator
{
    int __total__i;
};
static inline struct accumulator ___operator_assign__F12saccumulator_P12saccumulator12saccumulator_(struct accumulator *___dst__P12saccumulator, struct accumulator ___src__12saccumulator){
    ___operator_assign__Fi_Pii_((&(*___dst__P12saccumulator).__total__i), ___src__12saccumulator.__total__i);
    return ___src__12saccumulator;
}
char ___operator_call__Fc_12saccumulatorcc_(struct accumulator __a__12saccumulator, char __number1__c, char __number2__c);
void __f__F__(void){
    char __a__c;
    char __b__c;
    ___operator_call__Fi_ii_(((int )__a__c), ((int )__b__c));
    ___operator_call__Fi_ii_(((int )__a__c), ((int )__b__c));
    ___operator_add__Fi_ii_(((int )__a__c), ((int )__b__c));
    struct accumulator ___operator_add__12saccumulator;
    ___operator_call__Fc_12saccumulatorcc_(___operator_add__12saccumulator, __a__c, __b__c);
}