nameExpr is ?=?
decl is ?=?: automatically generated inline function
  with parameters
    _dst: pointer to instance of struct __anonymous0 
    _src: instance of struct __anonymous0 
  returning 
    instance of struct __anonymous0 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  b: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct __anonymous0 
              Member Expression, with field: 
                b: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct __anonymous0 

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



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


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 function
    with parameters
      _dst: pointer to instance of struct __anonymous0 
      _src: instance of struct __anonymous0 
    returning 
      instance of struct __anonymous0 

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

)
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: 
  b: signed int 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct __anonymous0 
(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: 
    b: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct __anonymous0 
(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: 
    b: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct __anonymous0 
(types:
    pointer to signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  b: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct __anonymous0 
(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: 
  b: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct __anonymous0 
(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 function
            with parameters
              _dst: pointer to instance of struct __anonymous0 
              _src: instance of struct __anonymous0 
            returning 
              instance of struct __anonymous0 

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

)
        Environment: 
formal type is pointer to instance of struct __anonymous0 
actual type is pointer to signed int 
actual expression:
        Address of:
          Member Expression, with field: 
            b: signed int 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct __anonymous0 
--- 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: 
          b: signed int 
        from aggregate: 
          Variable Expression: _src: instance of struct __anonymous0 
--- 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: 
              b: signed int 
            from aggregate: 
              Applying untyped: 
                  Name: *?
              ...to: 
                  Variable Expression: _dst: pointer to instance of struct __anonymous0 

                  Member Expression, with field: 
            b: signed int 
          from aggregate: 
            Variable Expression: _src: instance of struct __anonymous0 

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: 
        b: signed int 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct __anonymous0 

      Member Expression, with field: 
      b: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct __anonymous0 

(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: 
          b: signed int 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct __anonymous0 

          Member Expression, with field: 
        b: signed int 
      from aggregate: 
        Variable Expression: _src: instance of struct __anonymous0 


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 __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
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 __anonymous0 

to:
  instance of struct __anonymous0 
(types:
    instance of struct __anonymous0 
)
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: instance of struct __anonymous0 
newExpr is Variable Expression: a: instance of struct __anonymous0 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
Environment: 

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

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

Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
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===
__anonymous0
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
__anonymous0
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue instance of struct __anonymous0 
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 )
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: 

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
    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: instance of struct __anonymous0 
newExpr is Variable Expression: a: instance of struct __anonymous0 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
Environment: 

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

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

Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
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===
formal type is signed int 
actual type is lvalue instance of struct __anonymous0 
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 )
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: 

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: pointer to signed int 
newExpr is Variable Expression: b: pointer to signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 1 ): Cast of:
  Variable Expression: b: pointer 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: instance of struct __anonymous0 
newExpr is Variable Expression: a: instance of struct __anonymous0 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
Environment: 

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

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

Cost ( 0, 0, 0 ): Variable Expression: a: instance of struct __anonymous0 
(types:
    lvalue instance of struct __anonymous0 
)
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===
formal type is signed int 
actual type is lvalue instance of struct __anonymous0 
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 )
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: 

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: pointer to signed int 
newExpr is Variable Expression: b: pointer to signed int 

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

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

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
int ___operator_assign__Fi_Pii_(int *, int );
int ___operator_notequal__Fi_ii_(int , int );
int ___constant_zero__i;
void __f__F__(){
    int __a__i;
    struct __anonymous0
    {
        int __b__i;
    };
    inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_(struct __anonymous0 *___dst__P13s__anonymous0, struct __anonymous0 ___src__13s__anonymous0){
        ___operator_assign__Fi_Pii_((&(*___dst__P13s__anonymous0).__b__i), ___src__13s__anonymous0.__b__i);
        return ___src__13s__anonymous0;
    }
    struct __anonymous0 __a__13s__anonymous0;
    if (((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i))) {
        while (((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i))) {
            int *__b__Pi;
            for (__b__Pi;((int )___operator_notequal__Fi_ii_(__a__i, ___constant_zero__i));__b__Pi) {
            }

        }        

    }

}