x: signed int 
z: double 
struct __anonymous0
    with members
      a: signed int 
      b: double 

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

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

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



u: type for instance of struct __anonymous0 
?=?: automatically generated function
    with parameters
      _dst: pointer to instance of type u (not function type) 
      _src: instance of type u (not function type) 
    returning 
      instance of type u (not function type) 
    with body 
      CompoundStmt
                  Return Statement, returning: Applying untyped: 
    Name: ?=?
...to: 
    Cast of:
      Variable Expression: _dst: pointer to instance of type u (not function type) 

    to:
      pointer to instance of struct __anonymous0 
    Cast of:
      Variable Expression: _src: instance of type u (not function type) 

    to:
      instance of struct __anonymous0 



f: function
    with parameters
      y: signed int 
    returning 
      signed int 

q: double 
w: function
    with parameters
      y: double 
      v: instance of type u (not function type) 
    returning 
      double 
    with body 
      CompoundStmt
        Declaration of x: type
          with assertions
            t: function
                with parameters
                  instance of type u (not function type) 
                returning 
                  instance of type x (not function type) 


        Declaration of ?=?: automatically generated function
            with parameters
              _dst: pointer to instance of type x (not function type) 
              _src: instance of type x (not function type) 
            returning 
              instance of type x (not function type) 

        Declaration of u: instance of type u (not function type) with initializer 
          Simple Initializer:             Name: y

                  Expression Statement:
            Applying untyped: 
                Name: ?=?
            ...to: 
                Address of:
                  Name: u
                Name: y

        Declaration of z: instance of type x (not function type) with initializer 
          Simple Initializer:             Applying untyped: 
                Name: t
            ...to: 
                Name: u

                  Expression Statement:
            Applying untyped: 
                Name: ?=?
            ...to: 
                Address of:
                  Name: z
                Applying untyped: 
                    Name: t
                ...to: 
                    Name: u


p: double 
context has_u
    with parameters
      z: type

    with members
      u: function
          with parameters
            instance of type z (not function type) 
          returning 
            instance of type z (not function type) 


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

          u: pointer to function
              with parameters
                instance of type t (not function type) 
              returning 
                instance of type t (not function type) 


    function
    with parameters
      the_t: instance of type t (not function type) 
    returning 
      double 
    with body 
      CompoundStmt
        Declaration of y: instance of type t (not function type) with initializer 
          Simple Initializer:             Applying untyped: 
                Name: u
            ...to: 
                Name: the_t

                  Expression Statement:
            Applying untyped: 
                Name: ?=?
            ...to: 
                Address of:
                  Name: y
                Applying untyped: 
                    Name: u
                ...to: 
                    Name: the_t


f: function
    with parameters
      p: double 
    returning 
      float 
    with body 
      CompoundStmt
        Declaration of y: signed int 
                  CompoundStmt
            Declaration of y: char 
                          CompoundStmt
                Declaration of x: char 
                Declaration of z: char with initializer 
                  Simple Initializer:                     Name: x

                                  Expression Statement:
                    Applying untyped: 
                        Name: ?=?
                    ...to: 
                        Address of:
                          Name: z
                        Name: x


            Declaration of x: char with initializer 
              Simple Initializer:                 Name: y

                          Expression Statement:
                Applying untyped: 
                    Name: ?=?
                ...to: 
                    Address of:
                      Name: x
                    Name: y


        Declaration of q: char with initializer 
          Simple Initializer:             Name: y

                  Expression Statement:
            Applying untyped: 
                Name: ?=?
            ...to: 
                Address of:
                  Name: q
                Name: y


g: function
    returning 
      float 
    with body 
      CompoundStmt
                  Try Statement
            with block: 
              CompoundStmt
                                  Expression Statement:
                    Applying untyped: 
                        Name: some_func
                    ...to: 

            and handlers: 
              Catch Statement
              ... catching
x: char 

        Declaration of z: char 

q: function
      accepting unspecified arguments
    returning 
      double 
    with parameter names
      i
    with parameter declarations
      i: signed int 
    with body 
      CompoundStmt
                  Switch on condition: Name: i

              Case Name: 0

                  Return Statement, returning: Name: q

              Default 
                  Return Statement, returning: Name: i