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

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

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



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


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

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

)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  f2: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct inner 
(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: 
  f2: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct inner 
(types:
    lvalue signed int 
)
Environment: 

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

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

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

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

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



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


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

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

)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  f3: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct inner 
(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: 
  f3: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct inner 
(types:
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to signed int 
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _src: instance of struct inner 
(types:
    lvalue instance of struct inner 
)
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 inner 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

alternatives before prune:
Cost ( 0, 0, 0 ): Member Expression, with field: 
  f1: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct outer 
(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: 
  f1: signed int 
from aggregate: 
  Variable Expression: _src: instance of struct outer 
(types:
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

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

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to instance of struct inner 
formal type is instance of struct inner 
actual type is lvalue instance of struct inner 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Address of:
          Member Expression, with field: 
            i: instance of struct inner 
          from aggregate: 
            Applying untyped: 
                Name: *?
            ...to: 
                Variable Expression: _dst: pointer to instance of struct outer 
--- results are
        pointer to instance of struct inner 

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

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

                  Member Expression, with field: 
            i: instance of struct inner 
          from aggregate: 
            Variable Expression: _src: instance of struct outer 

bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: ?=?: inline static function
      with parameters
        _dst: pointer to instance of struct inner 
        _src: instance of struct inner 
      returning 
        instance of struct inner 

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

      Member Expression, with field: 
      i: instance of struct inner 
    from aggregate: 
      Variable Expression: _src: instance of struct outer 

(types:
    instance of struct inner 
)
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: ?=?: inline static function
        with parameters
          _dst: pointer to instance of struct inner 
          _src: instance of struct inner 
        returning 
          instance of struct inner 

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

          Member Expression, with field: 
        i: instance of struct inner 
      from aggregate: 
        Variable Expression: _src: instance of struct outer 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

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

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to double 
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: _src: instance of struct outer 
(types:
    lvalue instance of struct outer 
)
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 outer 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is y
decl is y: unsigned int 
newExpr is Variable Expression: y: unsigned int 

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

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

nameExpr is x
decl is x: short signed int 
newExpr is Variable Expression: x: short signed int 

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: y: unsigned int 

      Variable Expression: x: short signed int 

(types:
    lvalue unsigned int 
    lvalue short signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: y: unsigned int 

          Variable Expression: x: short signed int 

(types:
    pointer to unsigned int 
    pointer to short signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: y: unsigned int 

          Variable Expression: x: short signed int 

(types:
    pointer to unsigned int 
    pointer to short signed int 
)
Environment: 

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

nameExpr is y
decl is y: unsigned int 
newExpr is Variable Expression: y: unsigned int 

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: x: short signed int 

      Variable Expression: y: unsigned int 

(types:
    lvalue short signed int 
    lvalue unsigned int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

(types:
    pointer to short signed int 
    pointer to unsigned int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

(types:
    pointer to short signed int 
    pointer to unsigned int 
)
Environment: 

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 23 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 23 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: w: signed int 

  constant expression 23 signed int 
(types:
    lvalue signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: w: signed int 

  constant expression 23 signed int 
(types:
    lvalue signed int 
    signed int 
)
Environment: 

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: x: short signed int 
(types:
    pointer to short signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: x: short signed int 
(types:
    pointer to short signed int 
)
Environment: 

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

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

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

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

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

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to short signed int 
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

nameExpr is y
decl is y: unsigned int 
newExpr is Variable Expression: y: unsigned int 

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

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

nameExpr is z
decl is z: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: z: tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: x: short signed int 

      Variable Expression: y: unsigned int 

      Variable Expression: z: tuple of types
        signed int 
        signed int 


(types:
    lvalue short signed int 
    lvalue unsigned int 
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

          Variable Expression: z: tuple of types
          signed int 
          signed int 


(types:
    pointer to short signed int 
    pointer to unsigned int 
    pointer to signed int 
    pointer to signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

          Variable Expression: z: tuple of types
          signed int 
          signed int 


(types:
    pointer to short signed int 
    pointer to unsigned int 
    pointer to signed int 
    pointer to signed int 
)
Environment: 

nameExpr is p
decl is p: short signed int 
newExpr is Variable Expression: p: short signed int 

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

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

nameExpr is f
decl is f: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: f: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 17 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 17 signed int (types:
    signed int 
)
Environment: 

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

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

nameExpr is y
decl is y: unsigned int 
newExpr is Variable Expression: y: unsigned int 

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

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

nameExpr is z
decl is z: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: z: tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: x: short signed int 

      Variable Expression: y: unsigned int 

      Variable Expression: z: tuple of types
        signed int 
        signed int 


(types:
    lvalue short signed int 
    lvalue unsigned int 
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

          Variable Expression: z: tuple of types
          signed int 
          signed int 


(types:
    pointer to short signed int 
    pointer to unsigned int 
    pointer to signed int 
    pointer to signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: x: short signed int 

          Variable Expression: y: unsigned int 

          Variable Expression: z: tuple of types
          signed int 
          signed int 


(types:
    pointer to short signed int 
    pointer to unsigned int 
    pointer to signed int 
    pointer to signed int 
)
Environment: 

nameExpr is p
decl is p: short signed int 
newExpr is Variable Expression: p: short signed int 

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

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

nameExpr is f
decl is f: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: f: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 17 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 17 signed int (types:
    signed int 
)
Environment: 

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

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is r
decl is r: tuple of types
  signed int 
  char 
  long signed int 
  signed int 

newExpr is Variable Expression: r: tuple of types
    signed int 
    char 
    long signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: r: tuple of types
    signed int 
    char 
    long signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue char 
    lvalue long signed int 
    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:
  Variable Expression: r: tuple of types
      signed int 
      char 
      long signed int 
      signed int 

(types:
    pointer to signed int 
    pointer to char 
    pointer to long signed int 
    pointer to signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: r: tuple of types
      signed int 
      char 
      long signed int 
      signed int 

(types:
    pointer to signed int 
    pointer to char 
    pointer to long signed int 
    pointer to signed int 
)
Environment: 

nameExpr is x
decl is x: short signed int 
newExpr is Variable Expression: x: short signed int 

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

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

nameExpr is y
decl is y: unsigned int 
newExpr is Variable Expression: y: unsigned int 

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

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

nameExpr is z
decl is z: tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: z: tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: z: tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: x: short signed int 

      Variable Expression: y: unsigned int 

      Variable Expression: z: tuple of types
        signed int 
        signed int 


(types:
    lvalue short signed int 
    lvalue unsigned int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: x: short signed int 

      Variable Expression: y: unsigned int 

      Variable Expression: z: tuple of types
        signed int 
        signed int 


(types:
    lvalue short signed int 
    lvalue unsigned int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to signed int 
nameExpr is 1
nameExpr is f
decl is f: function
  with parameters
    signed int 
    signed int 
  returning 
    signed int 

newExpr is Variable Expression: f: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Tuple:
          constant expression 3 signed int 
          constant expression 5 signed int 
--- results are
        signed int 
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
actuals are:
                  Tuple:
            constant expression 3 signed int 
            constant expression 5 signed int 

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

to arguments
      Tuple:
      constant expression 3 signed int 
      constant expression 5 signed int 

(types:
    signed int 
)
Environment: 

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

  to arguments
          Tuple:
        constant expression 3 signed int 
        constant expression 5 signed int 


to:
  nothing
(types:
)
Environment: 

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

newExpr is Variable Expression: g: function
    with parameters
      signed int 
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
formal type is signed int 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Tuple:
          constant expression 3 signed int 
          constant expression 5 signed int 
--- results are
        signed int 
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
actual expression:
constant expression 3 signed int --- results are
        signed int 

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
actuals are:
                  Tuple:
            constant expression 3 signed int 
            constant expression 5 signed int 

        constant expression 3 signed int 
bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        signed int 
        signed int 
        signed int 
      returning 
        signed int 

to arguments
      Tuple:
      constant expression 3 signed int 
      constant expression 5 signed int 

  constant expression 3 signed int 
(types:
    signed int 
)
Environment: 

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

  to arguments
          Tuple:
        constant expression 3 signed int 
        constant expression 5 signed int 

    constant expression 3 signed int 

to:
  nothing
(types:
)
Environment: 

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

newExpr is Variable Expression: f: function
    with parameters
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: t1: const volatile tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
actuals are:
                  Variable Expression: t1: const volatile tuple of types
              signed int 
              signed int 


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

to arguments
      Variable Expression: t1: const volatile tuple of types
        signed int 
        signed int 


(types:
    signed int 
)
Environment: 

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

  to arguments
          Variable Expression: t1: const volatile tuple of types
          signed int 
          signed int 



to:
  nothing
(types:
)
Environment: 

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

newExpr is Variable Expression: g: function
    with parameters
      signed int 
      signed int 
      signed int 
    returning 
      signed int 


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

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

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is lvalue signed int 
formal type is signed int 
actual type is signed int 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
        Variable Expression: t1: const volatile tuple of types
            signed int 
            signed int 

--- results are
        lvalue signed int 
        lvalue signed int 

converting lvalue signed int 
 to signed int 
cost is( 0, 0, 0 )

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

converting signed int 
 to signed int 
cost is( 0, 0, 0 )
Case +++++++++++++
formals are:
        signed int 
        signed int 
        signed int 
actuals are:
                  Variable Expression: t1: const volatile tuple of types
              signed int 
              signed int 


        constant expression 3 signed int 
bindings are:
cost of conversion is:( 0, 0, 0 )
alternatives before prune:
Cost ( 0, 0, 0 ): Application of
  Variable Expression: g: function
      with parameters
        signed int 
        signed int 
        signed int 
      returning 
        signed int 

to arguments
      Variable Expression: t1: const volatile tuple of types
        signed int 
        signed int 


  constant expression 3 signed int 
(types:
    signed int 
)
Environment: 

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

  to arguments
          Variable Expression: t1: const volatile tuple of types
          signed int 
          signed int 


    constant expression 3 signed int 

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Cast of:
  Tuple:

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 2 ): Cast of:
  Tuple:
    constant expression 3 signed int 
    constant expression 5 signed int 

to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: a: signed int 
(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:
  Variable Expression: a: signed int 
(types:
    pointer to signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 4.6 double (types:
    double 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 4.6 double (types:
    double 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 4.6 double 
(types:
    double 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 4.6 double 
(types:
    double 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 5 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 5 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: c: signed int 
(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:
  Variable Expression: c: signed int 
(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:
  Variable Expression: c: signed int 
(types:
    pointer to signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

(types:
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

(types:
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

      Tuple:
              Variable Expression: c: signed int 


(types:
    lvalue signed int 
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

          Tuple:
                  Variable Expression: c: signed int 


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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

          Tuple:
                  Variable Expression: c: signed int 


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

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 2 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 2 signed int (types:
    signed int 
)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 2 signed int 
      Tuple:
              Variable Expression: a: signed int 

              Variable Expression: b: signed int 


(types:
    signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 2 signed int 
      Tuple:
              Variable Expression: a: signed int 

              Variable Expression: b: signed int 


(types:
    signed int 
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    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:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    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:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t2
decl is t2: static const tuple of types
  signed int 
  const signed int 

newExpr is Variable Expression: t2: static const tuple of types
    signed int 
    const signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t2: static const tuple of types
    signed int 
    const signed int 

(types:
    lvalue signed int 
    const 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:
  Variable Expression: t2: static const tuple of types
      signed int 
      const signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t2: static const tuple of types
      signed int 
      const signed int 

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

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: c: signed int 

          Variable Expression: d: signed int 

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

nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    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:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    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:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t2
decl is t2: static const tuple of types
  signed int 
  const signed int 

newExpr is Variable Expression: t2: static const tuple of types
    signed int 
    const signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t2: static const tuple of types
    signed int 
    const signed int 

(types:
    lvalue signed int 
    const 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:
  Variable Expression: t2: static const tuple of types
      signed int 
      const signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t2: static const tuple of types
      signed int 
      const signed int 

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

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

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

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

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

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

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

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: c: signed int 

      Variable Expression: d: signed int 

(types:
    lvalue signed int 
    lvalue signed int 
)
Environment: 

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

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

)
        Environment: 
formal type is pointer to instance of struct outer 
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 inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is t1
decl is t1: const volatile tuple of types
  signed int 
  signed int 

newExpr is Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: t1: const volatile tuple of types
    signed int 
    signed int 

(types:
    lvalue signed int 
    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:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: t1: const volatile tuple of types
      signed int 
      signed int 

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

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 4 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 4 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 3 signed int 
  constant expression 4 signed int 
(types:
    signed int 
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is s
decl is s: instance of struct outer 
newExpr is Variable Expression: s: instance of struct outer 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: s: instance of struct outer 
(types:
    pointer to instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: s: instance of struct outer 
(types:
    pointer to instance of struct outer 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 11 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 11 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 12 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 12 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 13 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 13 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3.14159 double (types:
    double 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3.14159 double (types:
    double 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
  constant expression 11 signed int 
  constant expression 12 signed int 
  constant expression 13 signed int 
  constant expression 3.14159 double 
(types:
    signed int 
    signed int 
    signed int 
    double 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Tuple:
  constant expression 11 signed int 
  constant expression 12 signed int 
  constant expression 13 signed int 
  constant expression 3.14159 double 
(types:
    signed int 
    signed int 
    signed int 
    double 
)
Environment: 

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

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

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

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

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to instance of struct outer 
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is s
decl is s: instance of struct outer 
newExpr is Variable Expression: s: instance of struct outer 

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: s: instance of struct outer 
(types:
    pointer to instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: s: instance of struct outer 
(types:
    pointer to instance of struct outer 
)
Environment: 

nameExpr is h
decl is h: static function
  with parameters
    a: signed int 
    b: signed int 
    c: pointer to signed int 
    d: pointer to char 
  returning 
    signed int 
    pointer to signed int 
    pointer to signed int 
    signed int 

newExpr is Variable Expression: h: static function
    with parameters
      a: signed int 
      b: signed int 
      c: pointer to signed int 
      d: pointer to char 
    returning 
      signed int 
      pointer to signed int 
      pointer to signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: h: static function
    with parameters
      a: signed int 
      b: signed int 
      c: pointer to signed int 
      d: pointer to char 
    returning 
      signed int 
      pointer to signed int 
      pointer to signed int 
      signed int 

(types:
    pointer to function
        with parameters
          a: signed int 
          b: signed int 
          c: pointer to signed int 
          d: pointer to char 
        returning 
          signed int 
          pointer to signed int 
          pointer to signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

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

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

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

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



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


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

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

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

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

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

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

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



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


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

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

)
Environment: 

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

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

)
Environment: 

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

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

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

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

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

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: b: signed int 
(types:
    lvalue signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): Tuple:
      Variable Expression: a: signed int 

      Variable Expression: b: signed int 

(types:
    lvalue signed int 
    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:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

(types:
    pointer to signed int 
    pointer to signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Tuple:
          Variable Expression: a: signed int 

          Variable Expression: b: signed int 

(types:
    pointer to signed int 
    pointer to signed int 
)
Environment: 

nameExpr is h
decl is h: static function
  with parameters
    a: signed int 
    b: signed int 
    c: pointer to signed int 
    d: pointer to char 
  returning 
    signed int 
    pointer to signed int 
    pointer to signed int 
    signed int 

newExpr is Variable Expression: h: static function
    with parameters
      a: signed int 
      b: signed int 
      c: pointer to signed int 
      d: pointer to char 
    returning 
      signed int 
      pointer to signed int 
      pointer to signed int 
      signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: h: static function
    with parameters
      a: signed int 
      b: signed int 
      c: pointer to signed int 
      d: pointer to char 
    returning 
      signed int 
      pointer to signed int 
      pointer to signed int 
      signed int 

(types:
    pointer to function
        with parameters
          a: signed int 
          b: signed int 
          c: pointer to signed int 
          d: pointer to char 
        returning 
          signed int 
          pointer to signed int 
          pointer to signed int 
          signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

alternatives before prune:
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression 3 signed int (types:
    signed int 
)
Environment: 

nameExpr is 0
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f3: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f3: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct inner 

to:
  instance of struct inner 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct inner 
      _src: instance of struct inner 
    returning 
      instance of struct inner 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct outer 
    _src: instance of struct outer 
  returning 
    instance of struct outer 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f1: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 
              Member Expression, with field: 
                f1: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

          to arguments
                          Address of:
                Member Expression, with field: 
                  i: instance of struct inner 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f4: double 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 
              Member Expression, with field: 
                f4: double 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct outer 

to:
  instance of struct outer 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct outer 
      _src: instance of struct outer 
    returning 
      instance of struct outer 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct inner 
      _src: instance of struct inner 
    returning 
      instance of struct inner 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of struct inner 
          _src: instance of struct inner 
        returning 
          instance of struct inner 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct outer 
      _src: instance of struct outer 
    returning 
      instance of struct outer 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of struct outer 
          _src: instance of struct outer 
        returning 
          instance of struct outer 

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is sp
decl is sp: pointer to instance of struct outer 
newExpr is Variable Expression: sp: pointer to instance of struct outer 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: sp: pointer to instance of struct outer 
(types:
    lvalue pointer to instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: sp: pointer to instance of struct outer 
(types:
    pointer to pointer to instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Address of:
  Variable Expression: sp: pointer to instance of struct outer 
(types:
    pointer to pointer to instance of struct outer 
)
Environment: 

nameExpr is sp
decl is sp: pointer to instance of struct outer 
newExpr is Variable Expression: sp: pointer to instance of struct outer 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: sp: pointer to instance of struct outer 
(types:
    lvalue pointer to instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: sp: pointer to instance of struct outer 
(types:
    lvalue pointer to instance of struct outer 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct outer 
              _src: instance of struct outer 
            returning 
              instance of struct outer 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of struct outer 
                  _src: instance of struct outer 
                returning 
                  instance of struct outer 

)
        Environment: 
formal type is pointer to instance of struct outer 
actual type is pointer to pointer to instance of struct outer 
working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: ?=?: inline static function
            with parameters
              _dst: pointer to instance of struct inner 
              _src: instance of struct inner 
            returning 
              instance of struct inner 

(types:
            pointer to function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

)
        Environment: 
formal type is pointer to instance of struct inner 
actual type is pointer to pointer to instance of struct outer 
nameExpr is printf
decl is printf: function
  with parameters
    fmt: pointer to char 
    and a variable number of other arguments
  returning 
    rc: signed int 

newExpr is Variable Expression: printf: function
    with parameters
      fmt: pointer to char 
      and a variable number of other arguments
    returning 
      rc: signed int 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: printf: function
    with parameters
      fmt: pointer to char 
      and a variable number of other arguments
    returning 
      rc: signed int 

(types:
    pointer to function
        with parameters
          fmt: pointer to char 
          and a variable number of other arguments
        returning 
          rc: signed int 

)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
alternatives before prune:
Cost ( 0, 0, 0 ): constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int (types:
    pointer to char 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int (types:
    pointer to char 
)
Environment: 

nameExpr is s
decl is s: instance of struct outer 
newExpr is Variable Expression: s: instance of struct outer 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: s: instance of struct outer 
(types:
    lvalue instance of struct outer 
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
findSubExprs
Cost ( 0, 0, 0 ): Variable Expression: s: instance of struct outer 
(types:
    lvalue instance of struct outer 
)
Environment: 

working on alternative: 
        Cost ( 0, 0, 0 ):         Variable Expression: printf: function
            with parameters
              fmt: pointer to char 
              and a variable number of other arguments
            returning 
              rc: signed int 

(types:
            pointer to function
                with parameters
                  fmt: pointer to char 
                  and a variable number of other arguments
                returning 
                  rc: signed int 

)
        Environment: 
formal type is pointer to char 
actual type is pointer to char 
need assertions:
============= original indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
============= new indexer
===idTable===
===typeTable===
===structTable===
===enumTable===
===unionTable===
===contextTable===
actual expression:
constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int --- results are
        pointer to char 

converting pointer to char 
 to pointer to char 
cost is( 0, 0, 0 )
actual expression:
        Variable Expression: s: instance of struct outer 
--- results are
        lvalue instance of struct outer 
Case +++++++++++++
formals are:
        fmt: pointer to char 
actuals are:
        constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int 
                  Variable Expression: s: instance of struct outer 

bindings are:
cost of conversion is:( 1, 0, 0 )
alternatives before prune:
Cost ( 1, 0, 0 ): Application of
  Variable Expression: printf: function
      with parameters
        fmt: pointer to char 
        and a variable number of other arguments
      returning 
        rc: signed int 

to arguments
  constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int 
      Variable Expression: s: instance of struct outer 

(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: printf: function
        with parameters
          fmt: pointer to char 
          and a variable number of other arguments
        returning 
          rc: signed int 

  to arguments
    constant expression "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n" array of char with dimension of constant expression 47 unsigned int 
          Variable Expression: s: instance of struct outer 


to:
  nothing
(types:
)
Environment: 

there are 1 alternatives before elimination
there are 1 alternatives after elimination
nameExpr is ?=?
decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct inner 
    _src: instance of struct inner 
  returning 
    instance of struct inner 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f2: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f2: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f3: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct inner 
              Member Expression, with field: 
                f3: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct inner 

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct inner 

to:
  instance of struct inner 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct inner 
      _src: instance of struct inner 
    returning 
      instance of struct inner 


decl is ?=?: automatically generated inline static function
  with parameters
    _dst: pointer to instance of struct outer 
    _src: instance of struct outer 
  returning 
    instance of struct outer 
  with body 
    CompoundStmt
              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f1: signed int 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 
              Member Expression, with field: 
                f1: signed int 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

              Expression Statement:
          Application of
            Variable Expression: ?=?: inline static function
                with parameters
                  _dst: pointer to instance of struct inner 
                  _src: instance of struct inner 
                returning 
                  instance of struct inner 

          to arguments
                          Address of:
                Member Expression, with field: 
                  i: instance of struct inner 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 

                          Member Expression, with field: 
                i: instance of struct inner 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

          with environment:
            Types:
            Non-types:

              Expression Statement:
          Applying untyped: 
              Name: ?=?
          ...to: 
              Address of:
                Member Expression, with field: 
                  f4: double 
                from aggregate: 
                  Applying untyped: 
                      Name: *?
                  ...to: 
                      Variable Expression: _dst: pointer to instance of struct outer 
              Member Expression, with field: 
                f4: double 
              from aggregate: 
                Variable Expression: _src: instance of struct outer 

              Return Statement, returning: Cast of:
  Variable Expression: _src: instance of struct outer 

to:
  instance of struct outer 
with environment:
  Types:
  Non-types:



newExpr is Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct outer 
      _src: instance of struct outer 
    returning 
      instance of struct outer 


alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct inner 
      _src: instance of struct inner 
    returning 
      instance of struct inner 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of struct inner 
          _src: instance of struct inner 
        returning 
          instance of struct inner 

)
Environment: 

Cost ( 0, 0, 0 ): Variable Expression: ?=?: inline static function
    with parameters
      _dst: pointer to instance of struct outer 
      _src: instance of struct outer 
    returning 
      instance of struct outer 

(types:
    pointer to function
        with parameters
          _dst: pointer to instance of struct outer 
          _src: instance of struct outer 
        returning 
          instance of struct outer 

)
Environment: 

there are 2 alternatives before elimination
there are 2 alternatives after elimination
nameExpr is rc
decl is rc: signed int 
newExpr is Variable Expression: rc: signed int 

alternatives before prune:
Cost ( 0, 0, 0 ): Variable Expression: rc: signed int 
(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:
  Variable Expression: rc: signed int 
(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:
  Variable Expression: rc: signed int 
(types:
    pointer to signed int 
)
Environment: 

nameExpr is 0
Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Member Expression, with field: 
        f2: signed int 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct inner 
    Member Expression, with field: 
      f2: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct inner 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Member Expression, with field: 
        f3: signed int 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct inner 
    Member Expression, with field: 
      f3: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct inner 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Member Expression, with field: 
        f1: signed int 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct outer 
    Member Expression, with field: 
      f1: signed int 
    from aggregate: 
      Variable Expression: _src: instance of struct outer 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Member Expression, with field: 
        f4: double 
      from aggregate: 
        Applying untyped: 
            Name: *?
        ...to: 
            Variable Expression: _dst: pointer to instance of struct outer 
    Member Expression, with field: 
      f4: double 
    from aggregate: 
      Variable Expression: _src: instance of struct outer 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Variable Expression: x: short signed int 
    Variable Expression: w: signed int 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: f
...to: 
constant expression 17 signed int 
Error: No reasonable alternatives for expression Applying untyped: 
    Name: f
...to: 
constant expression 17 signed int 
Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: r
    Tuple:
              Name: x

              Name: y

              Name: z


Error: No reasonable alternatives for expression Name: 1

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Variable Expression: a: signed int 
constant expression 3 signed int 
Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Tuple:
                  Name: a

                  Name: b

    Tuple:
      constant expression 4.6 double 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Variable Expression: c: signed int 
constant expression 3 signed int 
Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Tuple:
                  Name: a

                  Name: b

                  Tuple:
                          Name: c


    Tuple:
      constant expression 2 signed int 
              Tuple:
                      Name: a

                      Name: b



Error: No reasonable alternatives for expression Name: ?!=?

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: t1
    Tuple:
              Name: a

              Name: b


Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: t2
    Tuple:
              Name: a

              Name: b


Error: No reasonable alternatives for expression Name: ?+=?

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Tuple:
                  Name: c

                  Name: d

    Name: t1

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: t1
    Tuple:
              Name: c

              Name: d


Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: t2
    Tuple:
              Name: c

              Name: d


Error: No reasonable alternatives for expression Address of:
  Tuple:
    constant expression 3 signed int 
    constant expression 4 signed int 

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: s
    Tuple:
      constant expression 11 signed int 
      constant expression 12 signed int 
      constant expression 13 signed int 
      constant expression 3.14159 double 

Error: No reasonable alternatives for expression Name: 0

Error: No reasonable alternatives for expression Name: 0

Error: No reasonable alternatives for expression Applying untyped: 
    Name: ?=?
...to: 
    Address of:
      Name: sp
    Name: sp

Error: No reasonable alternatives for expression Name: 0