nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


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

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 
              Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 
              Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

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



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 5 alternatives before elimination
there are 5 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct a_struct 
(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: 
    a: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct a_struct 
(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: 
    a: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct a_struct 
(types:
    pointer to signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

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

                  Member Expression, with field: 
            a: signed int 
          from aggregate: 
            Variable Expression: _src: instance of struct a_struct 

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

      Member Expression, with field: 
      a: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct a_struct 

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

          Member Expression, with field: 
        a: signed int 
      from aggregate: 
        Variable Expression: _src: instance of struct a_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 
              Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 
              Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

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



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 5 alternatives before elimination
there are 5 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct a_struct 
(types:
    lvalue char 
)
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: 
    a: char 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct a_struct 
(types:
    pointer to char 
)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: _src: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: _src: instance of struct a_struct 
(types:
    lvalue char 
)
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 char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to float 
              float 
            returning 
              float 

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to 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===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

)
        Environment: 
formal type is pointer to pointer to instance of type _0_DT (not function type) 
actual type is pointer to char 
actual expression:
        Address of:
          Member Expression, with field: 
            a: char 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct a_struct 
--- results are
        pointer to char 

converting pointer to char 
 to pointer to char 
cost is( 0, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: char 
        from aggregate: 
          Variable Expression: _src: instance of struct a_struct 
--- results are
        lvalue char 

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

                  Member Expression, with field: 
            a: char 
          from aggregate: 
            Variable Expression: _src: instance of struct a_struct 

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 char 
        char 
      returning 
        char 

to arguments
      Address of:
      Member Expression, with field: 
        a: char 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct a_struct 

      Member Expression, with field: 
      a: char 
    from aggregate: 
      Variable Expression: _src: instance of struct a_struct 

(types:
    char 
)
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 char 
          char 
        returning 
          char 

  to arguments
          Address of:
        Member Expression, with field: 
          a: char 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct a_struct 

          Member Expression, with field: 
        a: char 
      from aggregate: 
        Variable Expression: _src: instance of struct a_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 
              Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

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



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 5 alternatives before elimination
there are 5 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct a_struct 
(types:
    lvalue float 
)
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: 
    a: float 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct a_struct 
(types:
    pointer to float 
)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: _src: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: _src: instance of struct a_struct 
(types:
    lvalue float 
)
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 float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to float 
              float 
            returning 
              float 

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to float 
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===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

)
        Environment: 
formal type is pointer to pointer to instance of type _0_DT (not function type) 
actual type is pointer to float 
actual expression:
        Address of:
          Member Expression, with field: 
            a: float 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct a_struct 
--- results are
        pointer to float 

converting pointer to float 
 to pointer to float 
cost is( 0, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: float 
        from aggregate: 
          Variable Expression: _src: instance of struct a_struct 
--- results are
        lvalue float 

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

                  Member Expression, with field: 
            a: float 
          from aggregate: 
            Variable Expression: _src: instance of struct a_struct 

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

to arguments
      Address of:
      Member Expression, with field: 
        a: float 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct a_struct 

      Member Expression, with field: 
      a: float 
    from aggregate: 
      Variable Expression: _src: instance of struct a_struct 

(types:
    float 
)
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 float 
          float 
        returning 
          float 

  to arguments
          Address of:
        Member Expression, with field: 
          a: float 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct a_struct 

          Member Expression, with field: 
        a: float 
      from aggregate: 
        Variable Expression: _src: instance of struct a_struct 


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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is __builtin_memcpy
decl is __builtin_memcpy: function
    accepting unspecified arguments
  returning 
    pointer to char 

newExpr is Variable Expression: __builtin_memcpy: function
      accepting unspecified arguments
    returning 
      pointer to char 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: __builtin_memcpy: function
      accepting unspecified arguments
    returning 
      pointer to char 

(types:
    pointer to function
          accepting unspecified arguments
        returning 
          pointer to char 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _dst: pointer to instance of union b_struct 
(types:
    lvalue pointer to instance of union b_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: _dst: pointer to instance of union b_struct 
(types:
    lvalue pointer to instance of union b_struct 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _src: instance of union b_struct 
(types:
    lvalue instance of union b_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: _src: instance of union b_struct 
(types:
    pointer to instance of union b_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: _src: instance of union b_struct 
(types:
    pointer to instance of union b_struct 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Sizeof Expression on: instance of union b_struct 
(types:
    unsigned int 
)
Environment: 

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

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: __builtin_memcpy: function
              accepting unspecified arguments
            returning 
              pointer to char 

(types:
            pointer to function
                  accepting unspecified arguments
                returning 
                  pointer to char 

)
        Environment: 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: _dst: pointer to instance of union b_struct 
--- results are
        lvalue pointer to instance of union b_struct 
actual expression:
        Address of:
          Variable Expression: _src: instance of union b_struct 
--- results are
        pointer to instance of union b_struct 
actual expression:
        Sizeof Expression on: instance of union b_struct 
--- results are
        unsigned int 
Case +++++++++++++
formals are:
actuals are:
                  Variable Expression: _dst: pointer to instance of union b_struct 

                  Address of:
            Variable Expression: _src: instance of union b_struct 

                  Sizeof Expression on: instance of union b_struct 

bindings are:
cost of conversion is:( 3, 0, 0 )
alternatives before prune:
Cost ( 3, 0, 0 ): Application of
  Variable Expression: __builtin_memcpy: function
        accepting unspecified arguments
      returning 
        pointer to char 

to arguments
      Variable Expression: _dst: pointer to instance of union b_struct 

      Address of:
      Variable Expression: _src: instance of union b_struct 

      Sizeof Expression on: instance of union b_struct 

(types:
    pointer to char 
)
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: __builtin_memcpy: function
          accepting unspecified arguments
        returning 
          pointer to char 

  to arguments
          Variable Expression: _dst: pointer to instance of union b_struct 

          Address of:
        Variable Expression: _src: instance of union b_struct 

          Sizeof Expression on: instance of union b_struct 


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 union b_struct 
(types:
    lvalue instance of union b_struct 
)
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 union b_struct 

to:
  instance of union b_struct 
(types:
    instance of union b_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is a
decl is a: function
  with parameters
    char 
  returning 
    nothing 

newExpr is Variable Expression: a: function
    with parameters
      char 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: function
    with parameters
      char 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          char 
        returning 
          nothing 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is the_struct
decl is the_struct: instance of struct a_struct 
newExpr is Variable Expression: the_struct: instance of struct a_struct 

decl is the_struct: instance of union b_struct 
newExpr is Variable Expression: the_struct: instance of union b_struct 

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

Cost ( 0, 0, 0 ): Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue instance of union b_struct 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

there are 6 alternatives before elimination
there are 6 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: a: function
            with parameters
              char 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  char 
                returning 
                  nothing 

)
        Environment: 
formal type is char 
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 char 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
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===
formal type is char 
actual type is lvalue pointer to signed int 
formal type is char 
actual type is lvalue pointer to float 
formal type is char 
actual type is lvalue pointer to char 
actual expression:
        Member Expression, with field: 
          a: signed int 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to char 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Cast of:
            Member Expression, with field: 
              a: signed int 
            from aggregate: 
              Variable Expression: the_struct: instance of struct a_struct 

          to:
            char 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: float 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue float 

converting lvalue float 
 to char 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Cast of:
            Member Expression, with field: 
              a: float 
            from aggregate: 
              Variable Expression: the_struct: instance of struct a_struct 

          to:
            char 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: char 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue char 

converting lvalue char 
 to char 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Member Expression, with field: 
            a: char 
          from aggregate: 
            Variable Expression: the_struct: instance of struct a_struct 

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

to arguments
      Cast of:
      Member Expression, with field: 
        a: signed int 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 

    to:
      char 

(types:
)
Environment: 

Cost ( 1, 0, 0 ): Application of
  Variable Expression: a: function
      with parameters
        char 
      returning 
        nothing 

to arguments
      Cast of:
      Member Expression, with field: 
        a: float 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 

    to:
      char 

(types:
)
Environment: 

Cost ( 0, 0, 0 ): Application of
  Variable Expression: a: function
      with parameters
        char 
      returning 
        nothing 

to arguments
      Member Expression, with field: 
      a: char 
    from aggregate: 
      Variable Expression: the_struct: instance of struct a_struct 

(types:
)
Environment: 

marking ambiguous
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: a: function
        with parameters
          char 
        returning 
          nothing 

  to arguments
          Member Expression, with field: 
        a: char 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 


to:
  nothing
(types:
)
Environment: 

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

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


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is the_struct
decl is the_struct: instance of struct a_struct 
newExpr is Variable Expression: the_struct: instance of struct a_struct 

decl is the_struct: instance of union b_struct 
newExpr is Variable Expression: the_struct: instance of union b_struct 

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

Cost ( 0, 0, 0 ): Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue instance of union b_struct 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

there are 6 alternatives before elimination
there are 6 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
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 signed int 
actual type is lvalue pointer to signed int 
formal type is signed int 
actual type is lvalue pointer to float 
formal type is signed int 
actual type is lvalue pointer to char 
actual expression:
        Member Expression, with field: 
          a: signed int 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Member Expression, with field: 
            a: signed int 
          from aggregate: 
            Variable Expression: the_struct: instance of struct a_struct 

bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: float 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue float 

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Member Expression, with field: 
              a: float 
            from aggregate: 
              Variable Expression: the_struct: instance of struct a_struct 

          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          a: char 
        from aggregate: 
          Variable Expression: the_struct: instance of struct a_struct 
--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Member Expression, with field: 
              a: char 
            from aggregate: 
              Variable Expression: the_struct: instance of struct a_struct 

          to:
            signed int 

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

to arguments
      Member Expression, with field: 
      a: signed int 
    from aggregate: 
      Variable Expression: the_struct: instance of struct a_struct 

(types:
)
Environment: 

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

to arguments
      Cast of:
      Member Expression, with field: 
        a: float 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 

    to:
      signed int 

(types:
)
Environment: 

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

to arguments
      Cast of:
      Member Expression, with field: 
        a: char 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 

    to:
      signed int 

(types:
)
Environment: 

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

  to arguments
          Member Expression, with field: 
        a: signed int 
      from aggregate: 
        Variable Expression: the_struct: instance of struct a_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is c
decl is c: function
  with parameters
    pointer to signed int 
  returning 
    nothing 

newExpr is Variable Expression: c: function
    with parameters
      pointer to signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: c: function
    with parameters
      pointer to signed int 
    returning 
      nothing 

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is the_struct
decl is the_struct: instance of struct a_struct 
newExpr is Variable Expression: the_struct: instance of struct a_struct 

decl is the_struct: instance of union b_struct 
newExpr is Variable Expression: the_struct: instance of union b_struct 

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

Cost ( 0, 0, 0 ): Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue instance of union b_struct 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

there are 6 alternatives before elimination
there are 6 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to signed int 
actual type is lvalue signed int 
formal type is pointer to signed int 
actual type is lvalue float 
formal type is pointer to signed int 
actual type is lvalue char 
formal type is pointer to signed int 
actual type is lvalue pointer to signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is pointer to signed int 
actual type is lvalue pointer to float 
formal type is pointer to signed int 
actual type is lvalue pointer to char 
actual expression:
        Member Expression, with field: 
          a: pointer to signed int 
        from aggregate: 
          Variable Expression: the_struct: instance of union b_struct 
--- results are
        lvalue pointer to signed int 

converting lvalue pointer to signed int 
 to pointer to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to signed int 
actuals are:
                  Member Expression, with field: 
            a: pointer to signed int 
          from aggregate: 
            Variable Expression: the_struct: instance of union b_struct 

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

to arguments
      Member Expression, with field: 
      a: pointer to signed int 
    from aggregate: 
      Variable Expression: the_struct: instance of union b_struct 

(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: c: function
        with parameters
          pointer to signed int 
        returning 
          nothing 

  to arguments
          Member Expression, with field: 
        a: pointer to signed int 
      from aggregate: 
        Variable Expression: the_struct: instance of union b_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is d
decl is d: function
  with parameters
    pointer to float 
  returning 
    nothing 

newExpr is Variable Expression: d: function
    with parameters
      pointer to float 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: d: function
    with parameters
      pointer to float 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          pointer to float 
        returning 
          nothing 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is the_struct
decl is the_struct: instance of struct a_struct 
newExpr is Variable Expression: the_struct: instance of struct a_struct 

decl is the_struct: instance of union b_struct 
newExpr is Variable Expression: the_struct: instance of union b_struct 

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

Cost ( 0, 0, 0 ): Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue instance of union b_struct 
)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

there are 6 alternatives before elimination
there are 6 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: signed int 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: float 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: char 
from aggregate: 
  Variable Expression: the_struct: instance of struct a_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to signed int 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to float 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Member Expression, with field: 
  a: pointer to char 
from aggregate: 
  Variable Expression: the_struct: instance of union b_struct 
(types:
    lvalue pointer to char 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: d: function
            with parameters
              pointer to float 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  pointer to float 
                returning 
                  nothing 

)
        Environment: 
formal type is pointer to float 
actual type is lvalue signed int 
formal type is pointer to float 
actual type is lvalue float 
formal type is pointer to float 
actual type is lvalue char 
formal type is pointer to float 
actual type is lvalue pointer to signed int 
formal type is pointer to float 
actual type is lvalue pointer to float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is pointer to float 
actual type is lvalue pointer to char 
actual expression:
        Member Expression, with field: 
          a: pointer to float 
        from aggregate: 
          Variable Expression: the_struct: instance of union b_struct 
--- results are
        lvalue pointer to float 

converting lvalue pointer to float 
 to pointer to float 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to float 
actuals are:
                  Member Expression, with field: 
            a: pointer to float 
          from aggregate: 
            Variable Expression: the_struct: instance of union b_struct 

bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: d: function
      with parameters
        pointer to float 
      returning 
        nothing 

to arguments
      Member Expression, with field: 
      a: pointer to float 
    from aggregate: 
      Variable Expression: the_struct: instance of union b_struct 

(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: d: function
        with parameters
          pointer to float 
        returning 
          nothing 

  to arguments
          Member Expression, with field: 
        a: pointer to float 
      from aggregate: 
        Variable Expression: the_struct: instance of union b_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct a_struct 

to:
  instance of struct a_struct 
with environment:
  Types:
  Non-types:



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


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

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 
              Member Expression, with field: 
                char 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 
              Member Expression, with field: 
                float 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

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



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union b_struct 

                          Address of:
                Variable Expression: _src: instance of union b_struct 

                          Sizeof Expression on: instance of union b_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union b_struct 

to:
  instance of union b_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of union b_struct 
      _src: instance of union b_struct 
    returning 
      instance of union b_struct 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of union b_struct 
          _src: instance of union b_struct 
        returning 
          instance of union b_struct 

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 7 alternatives before elimination
there are 7 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  signed int 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct c_struct 
(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: 
    signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct c_struct 
(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: 
    signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct c_struct 
(types:
    pointer to signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of union b_struct 
              _src: instance of union b_struct 
            returning 
              instance of union b_struct 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of union b_struct 
                  _src: instance of union b_struct 
                returning 
                  instance of union b_struct 

)
        Environment: 
formal type is pointer to instance of union b_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct c_struct 
              _src: instance of struct c_struct 
            returning 
              instance of struct c_struct 

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

)
        Environment: 
formal type is pointer to instance of struct c_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

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

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

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

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

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

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


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct a_struct 

to:
  instance of struct a_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct c_struct 
    _src: instance of struct c_struct 
  returning 
    instance of struct c_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

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

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 
              Member Expression, with field: 
                char 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 
              Member Expression, with field: 
                float 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

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



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union b_struct 

                          Address of:
                Variable Expression: _src: instance of union b_struct 

                          Sizeof Expression on: instance of union b_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union b_struct 

to:
  instance of union b_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of union b_struct 
      _src: instance of union b_struct 
    returning 
      instance of union b_struct 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of union b_struct 
          _src: instance of union b_struct 
        returning 
          instance of union b_struct 

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 7 alternatives before elimination
there are 7 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  char 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct c_struct 
(types:
    lvalue char 
)
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: 
    char 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct c_struct 
(types:
    pointer to char 
)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: _src: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: _src: instance of struct c_struct 
(types:
    lvalue char 
)
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 char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to float 
              float 
            returning 
              float 

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to 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===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of union b_struct 
              _src: instance of union b_struct 
            returning 
              instance of union b_struct 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of union b_struct 
                  _src: instance of union b_struct 
                returning 
                  instance of union b_struct 

)
        Environment: 
formal type is pointer to instance of union b_struct 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct c_struct 
              _src: instance of struct c_struct 
            returning 
              instance of struct c_struct 

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

)
        Environment: 
formal type is pointer to instance of struct c_struct 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to char 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

)
        Environment: 
formal type is pointer to pointer to instance of type _0_DT (not function type) 
actual type is pointer to char 
actual expression:
        Address of:
          Member Expression, with field: 
            char 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct c_struct 
--- results are
        pointer to char 

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

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

                  Member Expression, with field: 
            char 
          from aggregate: 
            Variable Expression: _src: instance of struct c_struct 

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 char 
        char 
      returning 
        char 

to arguments
      Address of:
      Member Expression, with field: 
        char 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct c_struct 

      Member Expression, with field: 
      char 
    from aggregate: 
      Variable Expression: _src: instance of struct c_struct 

(types:
    char 
)
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 char 
          char 
        returning 
          char 

  to arguments
          Address of:
        Member Expression, with field: 
          char 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct c_struct 

          Member Expression, with field: 
        char 
      from aggregate: 
        Variable Expression: _src: instance of struct c_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct a_struct 

to:
  instance of struct a_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct c_struct 
    _src: instance of struct c_struct 
  returning 
    instance of struct c_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

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

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 

                          Member Expression, with field: 
                char 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 
              Member Expression, with field: 
                float 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

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



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union b_struct 

                          Address of:
                Variable Expression: _src: instance of union b_struct 

                          Sizeof Expression on: instance of union b_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union b_struct 

to:
  instance of union b_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of union b_struct 
      _src: instance of union b_struct 
    returning 
      instance of union b_struct 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of union b_struct 
          _src: instance of union b_struct 
        returning 
          instance of union b_struct 

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 7 alternatives before elimination
there are 7 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  float 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct c_struct 
(types:
    lvalue float 
)
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: 
    float 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct c_struct 
(types:
    pointer to float 
)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: _src: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: _src: instance of struct c_struct 
(types:
    lvalue float 
)
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 float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to float 
              float 
            returning 
              float 

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to float 
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===
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of union b_struct 
              _src: instance of union b_struct 
            returning 
              instance of union b_struct 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of union b_struct 
                  _src: instance of union b_struct 
                returning 
                  instance of union b_struct 

)
        Environment: 
formal type is pointer to instance of union b_struct 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct c_struct 
              _src: instance of struct c_struct 
            returning 
              instance of struct c_struct 

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

)
        Environment: 
formal type is pointer to instance of struct c_struct 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to float 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

)
        Environment: 
formal type is pointer to pointer to instance of type _0_DT (not function type) 
actual type is pointer to float 
actual expression:
        Address of:
          Member Expression, with field: 
            float 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct c_struct 
--- results are
        pointer to float 

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

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

                  Member Expression, with field: 
            float 
          from aggregate: 
            Variable Expression: _src: instance of struct c_struct 

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

to arguments
      Address of:
      Member Expression, with field: 
        float 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct c_struct 

      Member Expression, with field: 
      float 
    from aggregate: 
      Variable Expression: _src: instance of struct c_struct 

(types:
    float 
)
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 float 
          float 
        returning 
          float 

  to arguments
          Address of:
        Member Expression, with field: 
          float 
        from aggregate: 
          Applying untyped: 
              Name: *?
          ...to: 
              Variable Expression: _dst: pointer to instance of struct c_struct 

          Member Expression, with field: 
        float 
      from aggregate: 
        Variable Expression: _src: instance of struct c_struct 


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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is __builtin_memcpy
decl is __builtin_memcpy: function
    accepting unspecified arguments
  returning 
    pointer to char 

newExpr is Variable Expression: __builtin_memcpy: function
      accepting unspecified arguments
    returning 
      pointer to char 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: __builtin_memcpy: function
      accepting unspecified arguments
    returning 
      pointer to char 

(types:
    pointer to function
          accepting unspecified arguments
        returning 
          pointer to char 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _dst: pointer to instance of union d_struct 
(types:
    lvalue pointer to instance of union d_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: _dst: pointer to instance of union d_struct 
(types:
    lvalue pointer to instance of union d_struct 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _src: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: _src: instance of union d_struct 
(types:
    pointer to instance of union d_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: _src: instance of union d_struct 
(types:
    pointer to instance of union d_struct 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Sizeof Expression on: instance of union d_struct 
(types:
    unsigned int 
)
Environment: 

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

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: __builtin_memcpy: function
              accepting unspecified arguments
            returning 
              pointer to char 

(types:
            pointer to function
                  accepting unspecified arguments
                returning 
                  pointer to char 

)
        Environment: 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: _dst: pointer to instance of union d_struct 
--- results are
        lvalue pointer to instance of union d_struct 
actual expression:
        Address of:
          Variable Expression: _src: instance of union d_struct 
--- results are
        pointer to instance of union d_struct 
actual expression:
        Sizeof Expression on: instance of union d_struct 
--- results are
        unsigned int 
Case +++++++++++++
formals are:
actuals are:
                  Variable Expression: _dst: pointer to instance of union d_struct 

                  Address of:
            Variable Expression: _src: instance of union d_struct 

                  Sizeof Expression on: instance of union d_struct 

bindings are:
cost of conversion is:( 3, 0, 0 )
alternatives before prune:
Cost ( 3, 0, 0 ): Application of
  Variable Expression: __builtin_memcpy: function
        accepting unspecified arguments
      returning 
        pointer to char 

to arguments
      Variable Expression: _dst: pointer to instance of union d_struct 

      Address of:
      Variable Expression: _src: instance of union d_struct 

      Sizeof Expression on: instance of union d_struct 

(types:
    pointer to char 
)
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: __builtin_memcpy: function
          accepting unspecified arguments
        returning 
          pointer to char 

  to arguments
          Variable Expression: _dst: pointer to instance of union d_struct 

          Address of:
        Variable Expression: _src: instance of union d_struct 

          Sizeof Expression on: instance of union d_struct 


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 union d_struct 
(types:
    lvalue instance of union d_struct 
)
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 union d_struct 

to:
  instance of union d_struct 
(types:
    instance of union d_struct 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is a
decl is a: function
  with parameters
    char 
  returning 
    nothing 

newExpr is Variable Expression: a: function
    with parameters
      char 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: a: function
    with parameters
      char 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          char 
        returning 
          nothing 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is x
decl is x: instance of struct c_struct 
newExpr is Variable Expression: x: instance of struct c_struct 

decl is x: instance of union d_struct 
newExpr is Variable Expression: x: instance of union d_struct 

decl is x: short unsigned int 
newExpr is Variable Expression: x: short unsigned int 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  signed int 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of struct c_struct 
(types:
    lvalue instance of struct c_struct 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: a: function
            with parameters
              char 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  char 
                returning 
                  nothing 

)
        Environment: 
formal type is char 
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 char 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
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===
formal type is char 
actual type is lvalue short unsigned int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is char 
actual type is lvalue pointer to signed int 
formal type is char 
actual type is lvalue pointer to float 
formal type is char 
actual type is lvalue pointer to char 
formal type is char 
actual type is lvalue instance of union d_struct 
formal type is char 
actual type is lvalue instance of struct c_struct 
actual expression:
        Member Expression, with field: 
          signed int 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to char 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Cast of:
            Member Expression, with field: 
              signed int 
            from aggregate: 
              Variable Expression: x: instance of struct c_struct 

          to:
            char 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          float 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue float 

converting lvalue float 
 to char 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Cast of:
            Member Expression, with field: 
              float 
            from aggregate: 
              Variable Expression: x: instance of struct c_struct 

          to:
            char 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          char 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue char 

converting lvalue char 
 to char 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Member Expression, with field: 
            char 
          from aggregate: 
            Variable Expression: x: instance of struct c_struct 

bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Variable Expression: x: short unsigned int 
--- results are
        lvalue short unsigned int 

converting lvalue short unsigned int 
 to char 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        char 
actuals are:
                  Cast of:
            Variable Expression: x: short unsigned int 

          to:
            char 

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

to arguments
      Cast of:
      Variable Expression: x: short unsigned int 

    to:
      char 

(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: a: function
        with parameters
          char 
        returning 
          nothing 

  to arguments
          Cast of:
        Variable Expression: x: short unsigned int 

      to:
        char 


to:
  nothing
(types:
)
Environment: 

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

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


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is x
decl is x: instance of struct c_struct 
newExpr is Variable Expression: x: instance of struct c_struct 

decl is x: instance of union d_struct 
newExpr is Variable Expression: x: instance of union d_struct 

decl is x: short unsigned int 
newExpr is Variable Expression: x: short unsigned int 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  signed int 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of struct c_struct 
(types:
    lvalue instance of struct c_struct 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is signed int 
actual type is lvalue float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
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 signed int 
actual type is lvalue short unsigned 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 pointer to signed int 
formal type is signed int 
actual type is lvalue pointer to float 
formal type is signed int 
actual type is lvalue pointer to char 
formal type is signed int 
actual type is lvalue instance of union d_struct 
formal type is signed int 
actual type is lvalue instance of struct c_struct 
actual expression:
        Member Expression, with field: 
          signed int 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Member Expression, with field: 
            signed int 
          from aggregate: 
            Variable Expression: x: instance of struct c_struct 

bindings are:
cost of conversion is:( 0, 0, 0 )
actual expression:
        Member Expression, with field: 
          float 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue float 

converting lvalue float 
 to signed int 
cost is( 1, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Member Expression, with field: 
              float 
            from aggregate: 
              Variable Expression: x: instance of struct c_struct 

          to:
            signed int 

bindings are:
cost of conversion is:( 1, 0, 0 )
actual expression:
        Member Expression, with field: 
          char 
        from aggregate: 
          Variable Expression: x: instance of struct c_struct 
--- results are
        lvalue char 

converting lvalue char 
 to signed int 
cost is( 0, 0, 4 )
Case +++++++++++++
formals are:
        signed int 
actuals are:
                  Cast of:
            Member Expression, with field: 
              char 
            from aggregate: 
              Variable Expression: x: instance of struct c_struct 

          to:
            signed int 

bindings are:
cost of conversion is:( 0, 0, 4 )
actual expression:
        Variable Expression: x: short unsigned int 
--- results are
        lvalue short unsigned int 

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

          to:
            signed int 

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

to arguments
      Cast of:
      Variable Expression: x: short unsigned int 

    to:
      signed int 

(types:
)
Environment: 

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

  to arguments
          Cast of:
        Variable Expression: x: short unsigned int 

      to:
        signed int 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is c
decl is c: function
  with parameters
    pointer to signed int 
  returning 
    nothing 

newExpr is Variable Expression: c: function
    with parameters
      pointer to signed int 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: c: function
    with parameters
      pointer to signed int 
    returning 
      nothing 

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is x
decl is x: instance of struct c_struct 
newExpr is Variable Expression: x: instance of struct c_struct 

decl is x: instance of union d_struct 
newExpr is Variable Expression: x: instance of union d_struct 

decl is x: short unsigned int 
newExpr is Variable Expression: x: short unsigned int 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  signed int 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of struct c_struct 
(types:
    lvalue instance of struct c_struct 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to signed int 
actual type is lvalue signed int 
formal type is pointer to signed int 
actual type is lvalue float 
formal type is pointer to signed int 
actual type is lvalue char 
formal type is pointer to signed int 
actual type is lvalue short unsigned int 
formal type is pointer to signed int 
actual type is lvalue pointer to signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is pointer to signed int 
actual type is lvalue pointer to float 
formal type is pointer to signed int 
actual type is lvalue pointer to char 
formal type is pointer to signed int 
actual type is lvalue instance of union d_struct 
formal type is pointer to signed int 
actual type is lvalue instance of struct c_struct 
actual expression:
        Member Expression, with field: 
          pointer to signed int 
        from aggregate: 
          Variable Expression: x: instance of union d_struct 
--- results are
        lvalue pointer to signed int 

converting lvalue pointer to signed int 
 to pointer to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to signed int 
actuals are:
                  Member Expression, with field: 
            pointer to signed int 
          from aggregate: 
            Variable Expression: x: instance of union d_struct 

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

to arguments
      Member Expression, with field: 
      pointer to signed int 
    from aggregate: 
      Variable Expression: x: instance of union d_struct 

(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: c: function
        with parameters
          pointer to signed int 
        returning 
          nothing 

  to arguments
          Member Expression, with field: 
        pointer to signed int 
      from aggregate: 
        Variable Expression: x: instance of union d_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is d
decl is d: function
  with parameters
    pointer to float 
  returning 
    nothing 

newExpr is Variable Expression: d: function
    with parameters
      pointer to float 
    returning 
      nothing 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: d: function
    with parameters
      pointer to float 
    returning 
      nothing 

(types:
    pointer to function
        with parameters
          pointer to float 
        returning 
          nothing 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is x
decl is x: instance of struct c_struct 
newExpr is Variable Expression: x: instance of struct c_struct 

decl is x: instance of union d_struct 
newExpr is Variable Expression: x: instance of union d_struct 

decl is x: short unsigned int 
newExpr is Variable Expression: x: short unsigned int 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  signed int 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

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

Cost ( 0, 0, 1 ): Member Expression, with field: 
  float 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  char 
from aggregate: 
  Variable Expression: x: instance of struct c_struct 
(types:
    lvalue char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: short unsigned int 
(types:
    lvalue short unsigned int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to signed int 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to signed int 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to float 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to float 
)
Environment: 

Cost ( 0, 0, 1 ): Member Expression, with field: 
  pointer to char 
from aggregate: 
  Variable Expression: x: instance of union d_struct 
(types:
    lvalue pointer to char 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of union d_struct 
(types:
    lvalue instance of union d_struct 
)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: x: instance of struct c_struct 
(types:
    lvalue instance of struct c_struct 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: d: function
            with parameters
              pointer to float 
            returning 
              nothing 

(types:
            pointer to function
                with parameters
                  pointer to float 
                returning 
                  nothing 

)
        Environment: 
formal type is pointer to float 
actual type is lvalue signed int 
formal type is pointer to float 
actual type is lvalue float 
formal type is pointer to float 
actual type is lvalue char 
formal type is pointer to float 
actual type is lvalue short unsigned int 
formal type is pointer to float 
actual type is lvalue pointer to signed int 
formal type is pointer to float 
actual type is lvalue pointer to float 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
formal type is pointer to float 
actual type is lvalue pointer to char 
formal type is pointer to float 
actual type is lvalue instance of union d_struct 
formal type is pointer to float 
actual type is lvalue instance of struct c_struct 
actual expression:
        Member Expression, with field: 
          pointer to float 
        from aggregate: 
          Variable Expression: x: instance of union d_struct 
--- results are
        lvalue pointer to float 

converting lvalue pointer to float 
 to pointer to float 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to float 
actuals are:
                  Member Expression, with field: 
            pointer to float 
          from aggregate: 
            Variable Expression: x: instance of union d_struct 

bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: d: function
      with parameters
        pointer to float 
      returning 
        nothing 

to arguments
      Member Expression, with field: 
      pointer to float 
    from aggregate: 
      Variable Expression: x: instance of union d_struct 

(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: d: function
        with parameters
          pointer to float 
        returning 
          nothing 

  to arguments
          Member Expression, with field: 
        pointer to float 
      from aggregate: 
        Variable Expression: x: instance of union d_struct 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

newExpr is Variable Expression: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 


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

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



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct a_struct 

to:
  instance of struct a_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct c_struct 
    _src: instance of struct c_struct 
  returning 
    instance of struct c_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

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

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 

                          Member Expression, with field: 
                char 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 

                          Member Expression, with field: 
                float 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct c_struct 

to:
  instance of struct c_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union b_struct 

                          Address of:
                Variable Expression: _src: instance of union b_struct 

                          Sizeof Expression on: instance of union b_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union b_struct 

to:
  instance of union b_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union d_struct 
    _src: instance of union d_struct 
  returning 
    instance of union d_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union d_struct 

                          Address of:
                Variable Expression: _src: instance of union d_struct 

                          Sizeof Expression on: instance of union d_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union d_struct 

to:
  instance of union d_struct 
with environment:
  Types:
  Non-types:



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


decl is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

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


decl is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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


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: ?=?: forall
      DT: incomplete type
    function
    with parameters
      pointer to pointer to instance of type DT (not function type) 
      pointer to instance of type DT (not function type) 
    returning 
      pointer to instance of type DT (not function type) 

(types:
    pointer to forall
          _0_DT: incomplete type
        function
        with parameters
          pointer to pointer to instance of type _0_DT (not function type) 
          pointer to instance of type _0_DT (not function type) 
        returning 
          pointer to instance of type _0_DT (not function type) 

)
Environment: 

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

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

)
Environment: 

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

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

)
Environment: 

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

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

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of union b_struct 
      _src: instance of union b_struct 
    returning 
      instance of union b_struct 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of union b_struct 
          _src: instance of union b_struct 
        returning 
          instance of union b_struct 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of union d_struct 
      _src: instance of union d_struct 
    returning 
      instance of union d_struct 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of union d_struct 
          _src: instance of union d_struct 
        returning 
          instance of union d_struct 

)
Environment: 

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

(types:
    pointer to function
        with parameters
          pointer to char 
          char 
        returning 
          char 

)
Environment: 

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

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

)
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 9 alternatives before elimination
there are 9 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  y: signed int 
from aggregate: 
  Applying untyped: 
      Name: *?
  ...to: 
      Variable Expression: _dst: pointer to instance of struct forward 
(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: 
    y: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct forward 
(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: 
    y: signed int 
  from aggregate: 
    Applying untyped: 
        Name: *?
    ...to: 
        Variable Expression: _dst: pointer to instance of struct forward 
(types:
    pointer to signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to float 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: function
            with parameters
              pointer to char 
              char 
            returning 
              char 

(types:
            pointer to function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of union d_struct 
              _src: instance of union d_struct 
            returning 
              instance of union d_struct 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of union d_struct 
                  _src: instance of union d_struct 
                returning 
                  instance of union d_struct 

)
        Environment: 
formal type is pointer to instance of union d_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of union b_struct 
              _src: instance of union b_struct 
            returning 
              instance of union b_struct 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of union b_struct 
                  _src: instance of union b_struct 
                returning 
                  instance of union b_struct 

)
        Environment: 
formal type is pointer to instance of union b_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct c_struct 
              _src: instance of struct c_struct 
            returning 
              instance of struct c_struct 

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

)
        Environment: 
formal type is pointer to instance of struct c_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct a_struct 
              _src: instance of struct a_struct 
            returning 
              instance of struct a_struct 

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

)
        Environment: 
formal type is pointer to instance of struct a_struct 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct forward 
              _src: instance of struct forward 
            returning 
              instance of struct forward 

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

)
        Environment: 
formal type is pointer to instance of struct forward 
actual type is pointer to signed int 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: forall
              DT: incomplete type
            function
            with parameters
              pointer to pointer to instance of type DT (not function type) 
              pointer to instance of type DT (not function type) 
            returning 
              pointer to instance of type DT (not function type) 

(types:
            pointer to forall
                  _0_DT: incomplete type
                function
                with parameters
                  pointer to pointer to instance of type _0_DT (not function type) 
                  pointer to instance of type _0_DT (not function type) 
                returning 
                  pointer to instance of type _0_DT (not function type) 

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

                  Member Expression, with field: 
            y: signed int 
          from aggregate: 
            Variable Expression: _src: instance of struct forward 

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

      Member Expression, with field: 
      y: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct forward 

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

          Member Expression, with field: 
        y: signed int 
      from aggregate: 
        Variable Expression: _src: instance of struct forward 


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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is *?
decl is *?: forall
    T: type
      with assertions
        ?=?: pointer to function
            with parameters
              pointer to instance of type T (not function type) 
              instance of type T (not function type) 
            returning 
              instance of type T (not function type) 


  function
  with parameters
    pointer to instance of type T (not function type) 
  returning 
    lvalue instance of type T (not function type) 

newExpr is Variable Expression: *?: forall
      T: type
        with assertions
          ?=?: pointer to function
              with parameters
                pointer to instance of type T (not function type) 
                instance of type T (not function type) 
              returning 
                instance of type T (not function type) 


    function
    with parameters
      pointer to instance of type T (not function type) 
    returning 
      lvalue instance of type T (not function type) 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: *?: forall
      T: type
        with assertions
          ?=?: pointer to function
              with parameters
                pointer to instance of type T (not function type) 
                instance of type T (not function type) 
              returning 
                instance of type T (not function type) 


    function
    with parameters
      pointer to instance of type T (not function type) 
    returning 
      lvalue instance of type T (not function type) 

(types:
    pointer to forall
          _0_T: type
            with assertions
              ?=?: pointer to function
                  with parameters
                    pointer to instance of type _0_T (not function type) 
                    instance of type _0_T (not function type) 
                  returning 
                    instance of type _0_T (not function type) 


        function
        with parameters
          pointer to instance of type _0_T (not function type) 
        returning 
          lvalue instance of type _0_T (not function type) 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is q
decl is q: pointer to instance of struct forward 
newExpr is Variable Expression: q: pointer to instance of struct forward 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: q: pointer to instance of struct forward 
(types:
    lvalue pointer to instance of struct forward 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: q: pointer to instance of struct forward 
(types:
    lvalue pointer to instance of struct forward 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: *?: forall
              T: type
                with assertions
                  ?=?: pointer to function
                      with parameters
                        pointer to instance of type T (not function type) 
                        instance of type T (not function type) 
                      returning 
                        instance of type T (not function type) 


            function
            with parameters
              pointer to instance of type T (not function type) 
            returning 
              lvalue instance of type T (not function type) 

(types:
            pointer to forall
                  _0_T: type
                    with assertions
                      ?=?: pointer to function
                          with parameters
                            pointer to instance of type _0_T (not function type) 
                            instance of type _0_T (not function type) 
                          returning 
                            instance of type _0_T (not function type) 


                function
                with parameters
                  pointer to instance of type _0_T (not function type) 
                returning 
                  lvalue instance of type _0_T (not function type) 

)
        Environment: 
formal type is pointer to instance of type _0_T (not function type) 
actual type is lvalue pointer to instance of struct forward 
need assertions:
?=?: pointer to function
          with parameters
            pointer to instance of type _0_T (not function type) 
            instance of type _0_T (not function type) 
          returning 
            instance of type _0_T (not function type) 
(used)============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
inferRecursive: assertion is ?=?: pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 

inferRecursive: candidate is ?=?: forall
    DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type DT (not function type) 
    pointer to instance of type DT (not function type) 
  returning 
    pointer to instance of type DT (not function type) 

unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to forall
    _1_DT: incomplete type
  function
  with parameters
    pointer to pointer to instance of type _1_DT (not function type) 
    pointer to instance of type _1_DT (not function type) 
  returning 
    pointer to instance of type _1_DT (not function type) 

inferRecursive: candidate is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct forward 
    _src: instance of struct forward 
  returning 
    instance of struct forward 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                y: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct forward 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct forward 

to:
  instance of struct forward 
with environment:
  Types:
  Non-types:



unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    _dst: pointer to instance of struct forward 
    _src: instance of struct forward 
  returning 
    instance of struct forward 

success!
satisfying assertion 25 ?=?: pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with declaration 79 ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct forward 
    _src: instance of struct forward 
  returning 
    instance of struct forward 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                y: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct forward 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct forward 

to:
  instance of struct forward 
with environment:
  Types:
  Non-types:



inferRecursive: candidate is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

                          Member Expression, with field: 
                a: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: char 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  a: float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct a_struct 

                          Member Expression, with field: 
                a: float 
              from aggregate: 
                Variable Expression: _src: instance of struct a_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct a_struct 

to:
  instance of struct a_struct 
with environment:
  Types:
  Non-types:



unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    _dst: pointer to instance of struct a_struct 
    _src: instance of struct a_struct 
  returning 
    instance of struct a_struct 

inferRecursive: candidate is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct c_struct 
    _src: instance of struct c_struct 
  returning 
    instance of struct c_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to signed int 
                  signed int 
                returning 
                  signed int 

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

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

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to char 
                  char 
                returning 
                  char 

          to arguments
                          Address of:
                Member Expression, with field: 
                  char 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 

                          Member Expression, with field: 
                char 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Application of
            Variable Expression: ?=?: function
                with parameters
                  pointer to float 
                  float 
                returning 
                  float 

          to arguments
                          Address of:
                Member Expression, with field: 
                  float 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct c_struct 

                          Member Expression, with field: 
                float 
              from aggregate: 
                Variable Expression: _src: instance of struct c_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct c_struct 

to:
  instance of struct c_struct 
with environment:
  Types:
  Non-types:



unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    _dst: pointer to instance of struct c_struct 
    _src: instance of struct c_struct 
  returning 
    instance of struct c_struct 

inferRecursive: candidate is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union b_struct 

                          Address of:
                Variable Expression: _src: instance of union b_struct 

                          Sizeof Expression on: instance of union b_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union b_struct 

to:
  instance of union b_struct 
with environment:
  Types:
  Non-types:



unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    _dst: pointer to instance of union b_struct 
    _src: instance of union b_struct 
  returning 
    instance of union b_struct 

inferRecursive: candidate is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of union d_struct 
    _src: instance of union d_struct 
  returning 
    instance of union d_struct 
  with body 
    CompoundStmt
              Expression Statement:
          Application of
            Variable Expression: __builtin_memcpy: function
                  accepting unspecified arguments
                returning 
                  pointer to char 

          to arguments
                          Variable Expression: _dst: pointer to instance of union d_struct 

                          Address of:
                Variable Expression: _src: instance of union d_struct 

                          Sizeof Expression on: instance of union d_struct 

          with environment:
            Types:
            Non-types:

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of union d_struct 

to:
  instance of union d_struct 
with environment:
  Types:
  Non-types:



unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    _dst: pointer to instance of union d_struct 
    _src: instance of union d_struct 
  returning 
    instance of union d_struct 

inferRecursive: candidate is ?=?: function
  with parameters
    pointer to char 
    char 
  returning 
    char 

unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    pointer to char 
    char 
  returning 
    char 

inferRecursive: candidate is ?=?: function
  with parameters
    pointer to float 
    float 
  returning 
    float 

unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    pointer to float 
    float 
  returning 
    float 

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

unifying pointer to function
  with parameters
    pointer to instance of type _0_T (not function type) 
    instance of type _0_T (not function type) 
  returning 
    instance of type _0_T (not function type) 
 with pointer to function
  with parameters
    pointer to signed int 
    signed int 
  returning 
    signed int 

actual expression:
        Variable Expression: q: pointer to instance of struct forward 
--- results are
        lvalue pointer to instance of struct forward 

converting lvalue pointer to instance of struct forward 
 to pointer to instance of type _0_T (not function type) 
cost is( 0, 0, 0 )

converting pointer to function
          with parameters
            _dst: pointer to instance of struct forward 
            _src: instance of struct forward 
          returning 
            instance of struct forward 

 to pointer to function
          with parameters
            pointer to instance of type _0_T (not function type) 
            instance of type _0_T (not function type) 
          returning 
            instance of type _0_T (not function type) 

cost of conversion is ( 0, 0, 0 )
Case +++++++++++++
formals are:
        pointer to instance of type _0_T (not function type) 
actuals are:
                  Variable Expression: q: pointer to instance of struct forward 

bindings are:
        ( _0_T ) -> instance of struct forward  (no widening)
cost of conversion is:( 0, 4, 0 )
alternatives before prune:
Cost ( 0, 4, 0 ): Application of
  Variable Expression: *?: forall
        T: type
          with assertions
            ?=?: pointer to function
                with parameters
                  pointer to instance of type T (not function type) 
                  instance of type T (not function type) 
                returning 
                  instance of type T (not function type) 


      function
      with parameters
        pointer to instance of type T (not function type) 
      returning 
        lvalue instance of type T (not function type) 

to arguments
      Variable Expression: q: pointer to instance of struct forward 

with inferred parameters:
  ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct forward 
      _src: instance of struct forward 
    returning 
      instance of struct forward 

(types:
    lvalue instance of type _0_T (not function type) 
)
Environment:   ( _0_T ) -> instance of struct forward  (no widening)


there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 4, 0 ): Member Expression, with field: 
  y: signed int 
from aggregate: 
  Application of
    Variable Expression: *?: forall
          T: type
            with assertions
              ?=?: pointer to function
                  with parameters
                    pointer to instance of type T (not function type) 
                    instance of type T (not function type) 
                  returning 
                    instance of type T (not function type) 


        function
        with parameters
          pointer to instance of type T (not function type) 
        returning 
          lvalue instance of type T (not function type) 

  to arguments
          Variable Expression: q: pointer to instance of struct forward 

  with inferred parameters:
    ?=?: inline static function
      with parameters
        _dst: pointer to instance of struct forward 
        _src: instance of struct forward 
      returning 
        instance of struct forward 

(types:
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 1 ): Cast of:
  Member Expression, with field: 
    y: signed int 
  from aggregate: 
    Application of
      Variable Expression: *?: forall
            T: type
              with assertions
                ?=?: pointer to function
                    with parameters
                      pointer to instance of type T (not function type) 
                      instance of type T (not function type) 
                    returning 
                      instance of type T (not function type) 


          function
          with parameters
            pointer to instance of type T (not function type) 
          returning 
            lvalue instance of type T (not function type) 

    to arguments
              Variable Expression: q: pointer to instance of struct forward 

    with inferred parameters:
      ?=?: inline static function
        with parameters
          _dst: pointer to instance of struct forward 
          _src: instance of struct forward 
        returning 
          instance of struct forward 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
Error: unbound type variable in application Application of
  Variable Expression: *?: forall
        T: type
          with assertions
            ?=?: pointer to function
                with parameters
                  pointer to instance of type T (not function type) 
                  instance of type T (not function type) 
                returning 
                  instance of type T (not function type) 


      function
      with parameters
        pointer to instance of type T (not function type) 
      returning 
        pointer to instance of type T (not function type) 

to arguments
      Variable Expression: q: pointer to instance of struct forward 

with inferred parameters:
  ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct forward 
      _src: instance of struct forward 
    returning 
      instance of struct forward