Merged revisions 24922-24923 via svnmerge from

https://lampsvn.epfl.ch/svn-repos/scala/scala/trunk

........
  r24922 | odersky | 2011-05-11 13:09:08 +0200 (Wed, 11 May 2011) | 1 line

  Closes #4560. Review by dragos.
........
  r24923 | plocinic | 2011-05-11 14:11:08 +0200 (Wed, 11 May 2011) | 1 line

  Closes #4565. Added also autogenerated tests made by iulian. review by
odersky and dragos ........

7 files changed, 6965 insertions, 20 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 406d819147..af2ebc4251 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -426,11 +426,14 @@ abstract class TreeGen {
    *  The idiom works only if the condition is using a volatile field.
    *  @see http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
    */
-  def mkDoubleCheckedLocking(clazz: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree = {
+  def mkDoubleCheckedLocking(clazz: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree =
+    mkDoubleCheckedLocking(mkAttributedThis(clazz), cond, syncBody, stats)
+
+  def mkDoubleCheckedLocking(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree = {
     If(cond,
        Block(
          mkSynchronized(
-           mkAttributedThis(clazz),
+           attrThis,
            If(cond, Block(syncBody: _*), EmptyTree)) ::
          stats: _*),
        EmptyTree)
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index ce76117cfd..41faf00a04 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -27,6 +27,23 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
     private val symbolsStoredAsStatic = mutable.Map.empty[String, Symbol]
     private def mkTerm(prefix: String): TermName = unit.freshTermName(prefix)
 
+    /** Kludge to provide a safe fix for #4560:
+     *  If we generate a reference in an implementation class, we
+     *  watch out for embedded This(..) nodes that point to the interface.
+     *  These must be wrong. We fix them by setting symbol and type to
+     *  the enclosing implementation class instead.
+     */
+    def safeREF(sym: Symbol) = {
+      def fix(tree: Tree): Tree = tree match {
+        case Select(qual, name) => treeCopy.Select(tree, fix(qual), name)
+        case This(_) if tree.symbol.isInterface && tree.symbol.name + "$class" == currentClass.name.toString =>
+          tree.setSymbol(currentClass).setType(currentClass.tpe)
+        case _ => tree
+      }
+      val tree = REF(sym)
+      if (currentClass.isImplClass) fix(tree) else tree
+    }
+
     //private val classConstantMeth = new HashMap[String, Symbol]
     //private val symbolStaticFields = new HashMap[String, (Symbol, Tree, Tree)]
 
@@ -106,7 +123,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
           val varDef = typedPos( VAL(varSym) === forInit )
           newStaticMembers append transform(varDef)
 
-          val varInit = typedPos( REF(varSym) === forInit )
+          val varInit = typedPos( safeREF(varSym) === forInit )
           newStaticInits append transform(varInit)
 
           varSym
@@ -149,7 +166,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
               addStaticMethodToClass("reflMethod$Method", List(ClassClass.tpe), MethodClass.tpe) {
                 case Pair(reflMethodSym, List(forReceiverSym)) =>
-                  (REF(forReceiverSym) DOT Class_getMethod)(LIT(method), REF(reflParamsCacheSym))
+                  (REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym))
               }
 
             case MONO_CACHE =>
@@ -191,11 +208,11 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
                 case Pair(reflMethodSym, List(forReceiverSym)) =>
                   BLOCK(
                     IF (isCacheEmpty(forReceiverSym)) THEN BLOCK(
-                      REF(reflMethodCacheSym) === ((REF(forReceiverSym) DOT getMethodSym)(LIT(method), REF(reflParamsCacheSym))) ,
-                      REF(reflClassCacheSym) === gen.mkSoftRef(REF(forReceiverSym)),
+                      safeREF(reflMethodCacheSym) === ((REF(forReceiverSym) DOT getMethodSym)(LIT(method), safeREF(reflParamsCacheSym))) ,
+                      safeREF(reflClassCacheSym) === gen.mkSoftRef(REF(forReceiverSym)),
                       UNIT
                     ) ENDIF,
-                    REF(reflMethodCacheSym)
+                    safeREF(reflMethodCacheSym)
                   )
               }
 
@@ -227,23 +244,23 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
               def mkNewPolyCache = gen.mkSoftRef(NEW(TypeTree(EmptyMethodCacheClass.tpe)))
               val reflPolyCacheSym: Symbol = addStaticVariableToClass("reflPoly$Cache", SoftReferenceClass.tpe, mkNewPolyCache, false)
-              def getPolyCache = fn(REF(reflPolyCacheSym), nme.get) AS_ATTR MethodCacheClass.tpe
+              def getPolyCache = fn(safeREF(reflPolyCacheSym), nme.get) AS_ATTR MethodCacheClass.tpe
 
               addStaticMethodToClass("reflMethod$Method", List(ClassClass.tpe), MethodClass.tpe)
                 { case Pair(reflMethodSym, List(forReceiverSym)) =>
                   val methodSym = reflMethodSym.newVariable(ad.pos, mkTerm("method")) setInfo MethodClass.tpe
 
                   BLOCK(
-                    IF (getPolyCache OBJ_EQ NULL) THEN (REF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
+                    IF (getPolyCache OBJ_EQ NULL) THEN (safeREF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
                     VAL(methodSym) === ((getPolyCache DOT methodCache_find)(REF(forReceiverSym))) ,
                     IF (REF(methodSym) OBJ_!= NULL) .
                       THEN (Return(REF(methodSym)))
                     ELSE {
-                      def methodSymRHS  = ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), REF(reflParamsCacheSym)))
+                      def methodSymRHS  = ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym)))
                       def cacheRHS      = ((getPolyCache DOT methodCache_add)(REF(forReceiverSym), REF(methodSym)))
                       BLOCK(
                         REF(methodSym)        === (REF(ensureAccessibleMethod) APPLY (methodSymRHS)),
-                        REF(reflPolyCacheSym) === gen.mkSoftRef(cacheRHS),
+                        safeREF(reflPolyCacheSym) === gen.mkSoftRef(cacheRHS),
                         Return(REF(methodSym))
                       )
                     }
@@ -374,7 +391,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
           def genDefaultCall = {
             // reflective method call machinery
             val invokeName  = MethodClass.tpe member nme.invoke_                                // reflect.Method.invoke(...)
-            def cache       = REF(reflectiveMethodCache(ad.symbol.name.toString, paramTypes))   // cache Symbol
+            def cache       = safeREF(reflectiveMethodCache(ad.symbol.name.toString, paramTypes))   // cache Symbol
             def lookup      = Apply(cache, List(qual GETCLASS))                                 // get Method object from cache
             def invokeArgs  = ArrayValue(TypeTree(ObjectClass.tpe), params)                     // args for invocation
             def invocation  = (lookup DOT invokeName)(qual, invokeArgs)                         // .invoke(qual, ...)
@@ -463,7 +480,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               assert(params.length == mparams.length)
               typedPos {
                 val sym = currentOwner.newValue(ad.pos, mkTerm("qual")) setInfo qual0.tpe
-                qual = REF(sym)
+                qual = safeREF(sym)
 
                 BLOCK(
                   VAL(sym) === qual0,
@@ -606,7 +623,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
         val staticFieldSym = getSymbolStaticField(symapp.pos, symname, rhs, symapp)
 
         // create a reference to a static field
-        val ntree = typedWithPos(symapp.pos)(REF(staticFieldSym))
+        val ntree = typedWithPos(symapp.pos)(safeREF(staticFieldSym))
 
         super.transform(ntree)
 
@@ -639,7 +656,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
         // create field definition and initialization
         val stfieldDef = theTyper.typed { atPos(pos)(VAL(stfieldSym) === rhs) }
-        val stfieldInit = theTyper.typed { atPos(pos)(REF(stfieldSym) === rhs) }
+        val stfieldInit = theTyper.typed { atPos(pos)(safeREF(stfieldSym) === rhs) }
 
         // add field definition to new defs
         newStaticMembers append stfieldDef
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 406e97bb8c..ac4f19f69d 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -828,12 +828,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         typedPos(init.head.pos)(BLOCK(result, retVal))
       }
 
-      def mkInnerClassAccessorDoubleChecked(clazz: Symbol, rhs: Tree): Tree =
+      def mkInnerClassAccessorDoubleChecked(attrThis: Tree, rhs: Tree): Tree =
         rhs match {
           case Block(List(assign), returnTree) =>
             val Assign(moduleVarRef, _) = assign
             val cond = Apply(Select(moduleVarRef, nme.eq),List(Literal(Constant(null))))
-            val doubleSynchrTree = gen.mkDoubleCheckedLocking(clazz, cond, List(assign), Nil)
+            val doubleSynchrTree = gen.mkDoubleCheckedLocking(attrThis, cond, List(assign), Nil)
             Block(List(doubleSynchrTree), returnTree)
           case _ =>
             assert(false, "Invalid getter " + rhs + " for module in class " + clazz)
@@ -890,8 +890,11 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
               else
                 stat
           case DefDef(mods, name, tp, vp, tpt, rhs)
-            if sym.isModule && !clazz.isTrait && !sym.hasFlag(BRIDGE) =>
-              val rhs1 = mkInnerClassAccessorDoubleChecked(clazz, rhs)
+            if sym.isModule && (!clazz.isTrait || clazz.isImplClass) && !sym.hasFlag(BRIDGE) =>
+              val attrThis =
+                if (clazz.isImplClass) gen.mkAttributedIdent(vp.head.head.symbol)
+                else gen.mkAttributedThis(clazz)
+              val rhs1 = mkInnerClassAccessorDoubleChecked(attrThis, rhs)
               treeCopy.DefDef(stat, mods, name, tp, vp, tpt, typedPos(stat.pos)(rhs1))
           case _ => stat
         }
@@ -1090,7 +1093,8 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
               val rhs  = gen.newModule(sym, vdef.symbol.tpe)
               val assignAndRet = gen.mkAssignAndReturn(vdef.symbol, rhs)
-              val rhs1 = mkInnerClassAccessorDoubleChecked(clazz, assignAndRet)
+              val attrThis = gen.mkAttributedThis(clazz)
+              val rhs1 = mkInnerClassAccessorDoubleChecked(attrThis, assignAndRet)
               addDef(position(sym), DefDef(sym, rhs1))
             } else if (!sym.isMethod) {
               // add fields
diff --git a/test/files/run/t4565_1.check b/test/files/run/t4565_1.check
new file mode 100644
index 0000000000..27ba77ddaf
--- /dev/null
+++ b/test/files/run/t4565_1.check
@@ -0,0 +1 @@
+true
diff --git a/test/files/run/t4565_1.scala b/test/files/run/t4565_1.scala
new file mode 100644
index 0000000000..1353355573
--- /dev/null
+++ b/test/files/run/t4565_1.scala
@@ -0,0 +1,14 @@
+trait T {
+  def foo = {
+    object A
+    def a(x: Any) = x == A
+    a(A)
+  }
+}
+
+object Test {
+  def main(args: Array[String]) {
+    val t = new T{}
+    println(t.foo)
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t4565_2.check b/test/files/run/t4565_2.check
new file mode 100644
index 0000000000..96f3dbc139
--- /dev/null
+++ b/test/files/run/t4565_2.check
@@ -0,0 +1,189 @@
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
diff --git a/test/files/run/t4565_2.scala b/test/files/run/t4565_2.scala
new file mode 100644
index 0000000000..2f72b077d2
--- /dev/null
+++ b/test/files/run/t4565_2.scala
@@ -0,0 +1,6717 @@
+
+
+class Class3_1 {
+
+  class Class2_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Class2_2).run }
+}
+
+
+object Object4_1 {
+
+  class Class2_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Class2_2).run } // trigger
+}
+
+
+trait Trait5_1 {
+
+  class Class2_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Class2_2).run }
+}
+
+
+class Class7_1 {
+
+  object Object6_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run } // trigger
+  }
+
+  def run { Object6_2.run }
+}
+
+
+object Object8_1 {
+
+  object Object6_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run } // trigger
+  }
+
+  def run { Object6_2.run } // trigger
+}
+
+
+trait Trait9_1 {
+
+  object Object6_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run } // trigger
+  }
+
+  def run { Object6_2.run }
+}
+
+
+class Class11_1 {
+
+  trait Trait10_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Trait10_2 {}).run }
+}
+
+
+object Object12_1 {
+
+  trait Trait10_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Trait10_2 {}).run } // trigger
+}
+
+
+trait Trait13_1 {
+
+  trait Trait10_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Class1_3).run }
+  }
+
+  def run { (new Trait10_2 {}).run }
+}
+
+
+class Class15_1 {
+
+  def method14_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { method14_2 }
+}
+
+
+object Object16_1 {
+
+  def method14_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { method14_2 } // trigger
+}
+
+
+trait Trait17_1 {
+
+  def method14_2 {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { method14_2 }
+}
+
+
+class Class19_1 {
+
+  val fun18_2 = () => {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { fun18_2() }
+}
+
+
+object Object20_1 {
+
+  val fun18_2 = () => {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { fun18_2() } // trigger
+}
+
+
+trait Trait21_1 {
+
+  val fun18_2 = () => {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { fun18_2() }
+}
+
+
+class Class23_1 {
+
+  class Class22_2 {
+    { // in primary constructor
+
+      class Class1_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Class1_3).run // trigger
+    }
+  }
+
+  def run { (new Class22_2) }
+}
+
+
+object Object24_1 {
+
+  class Class22_2 {
+    { // in primary constructor
+
+      class Class1_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Class1_3).run // trigger
+    }
+  }
+
+  def run { (new Class22_2) } // trigger
+}
+
+
+trait Trait25_1 {
+
+  class Class22_2 {
+    { // in primary constructor
+
+      class Class1_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Class1_3).run // trigger
+    }
+  }
+
+  def run { (new Class22_2) }
+}
+
+
+class Class27_1 {
+
+  lazy val lzvalue26_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { lzvalue26_2 }
+}
+
+
+object Object28_1 {
+
+  lazy val lzvalue26_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { lzvalue26_2 } // trigger
+}
+
+
+trait Trait29_1 {
+
+  lazy val lzvalue26_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { lzvalue26_2 }
+}
+
+
+class Class31_1 {
+
+  val value30_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { value30_2 }
+}
+
+
+object Object32_1 {
+
+  val value30_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { value30_2 } // trigger
+}
+
+
+trait Trait33_1 {
+
+  val value30_2 = {
+
+    class Class1_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Class1_3).run // trigger
+  }
+
+  def run { value30_2 }
+}
+
+
+class Class36_1 {
+
+  class Class35_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Class35_2).run }
+}
+
+
+object Object37_1 {
+
+  class Class35_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Class35_2).run } // trigger
+}
+
+
+trait Trait38_1 {
+
+  class Class35_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Class35_2).run }
+}
+
+
+class Class40_1 {
+
+  object Object39_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run } // trigger
+  }
+
+  def run { Object39_2.run }
+}
+
+
+object Object41_1 {
+
+  object Object39_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run } // trigger
+  }
+
+  def run { Object39_2.run } // trigger
+}
+
+
+trait Trait42_1 {
+
+  object Object39_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run } // trigger
+  }
+
+  def run { Object39_2.run }
+}
+
+
+class Class44_1 {
+
+  trait Trait43_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Trait43_2 {}).run }
+}
+
+
+object Object45_1 {
+
+  trait Trait43_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Trait43_2 {}).run } // trigger
+}
+
+
+trait Trait46_1 {
+
+  trait Trait43_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    def run { Object34_3.run }
+  }
+
+  def run { (new Trait43_2 {}).run }
+}
+
+
+class Class48_1 {
+
+  def method47_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { method47_2 }
+}
+
+
+object Object49_1 {
+
+  def method47_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { method47_2 } // trigger
+}
+
+
+trait Trait50_1 {
+
+  def method47_2 {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { method47_2 }
+}
+
+
+class Class52_1 {
+
+  val fun51_2 = () => {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { fun51_2() }
+}
+
+
+object Object53_1 {
+
+  val fun51_2 = () => {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { fun51_2() } // trigger
+}
+
+
+trait Trait54_1 {
+
+  val fun51_2 = () => {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { fun51_2() }
+}
+
+
+class Class56_1 {
+
+  class Class55_2 {
+    { // in primary constructor
+
+      object Object34_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest } // trigger
+      }
+
+      Object34_3.run // trigger
+    }
+  }
+
+  def run { (new Class55_2) }
+}
+
+
+object Object57_1 {
+
+  class Class55_2 {
+    { // in primary constructor
+
+      object Object34_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest } // trigger
+      }
+
+      Object34_3.run // trigger
+    }
+  }
+
+  def run { (new Class55_2) } // trigger
+}
+
+
+trait Trait58_1 {
+
+  class Class55_2 {
+    { // in primary constructor
+
+      object Object34_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest } // trigger
+      }
+
+      Object34_3.run // trigger
+    }
+  }
+
+  def run { (new Class55_2) }
+}
+
+
+class Class60_1 {
+
+  lazy val lzvalue59_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { lzvalue59_2 }
+}
+
+
+object Object61_1 {
+
+  lazy val lzvalue59_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { lzvalue59_2 } // trigger
+}
+
+
+trait Trait62_1 {
+
+  lazy val lzvalue59_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { lzvalue59_2 }
+}
+
+
+class Class64_1 {
+
+  val value63_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { value63_2 }
+}
+
+
+object Object65_1 {
+
+  val value63_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { value63_2 } // trigger
+}
+
+
+trait Trait66_1 {
+
+  val value63_2 = {
+
+    object Object34_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest } // trigger
+    }
+
+    Object34_3.run // trigger
+  }
+
+  def run { value63_2 }
+}
+
+
+class Class69_1 {
+
+  class Class68_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Class68_2).run }
+}
+
+
+object Object70_1 {
+
+  class Class68_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Class68_2).run } // trigger
+}
+
+
+trait Trait71_1 {
+
+  class Class68_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Class68_2).run }
+}
+
+
+class Class73_1 {
+
+  object Object72_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run } // trigger
+  }
+
+  def run { Object72_2.run }
+}
+
+
+object Object74_1 {
+
+  object Object72_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run } // trigger
+  }
+
+  def run { Object72_2.run } // trigger
+}
+
+
+trait Trait75_1 {
+
+  object Object72_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run } // trigger
+  }
+
+  def run { Object72_2.run }
+}
+
+
+class Class77_1 {
+
+  trait Trait76_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Trait76_2 {}).run }
+}
+
+
+object Object78_1 {
+
+  trait Trait76_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Trait76_2 {}).run } // trigger
+}
+
+
+trait Trait79_1 {
+
+  trait Trait76_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    def run { (new Trait67_3 {}).run }
+  }
+
+  def run { (new Trait76_2 {}).run }
+}
+
+
+class Class81_1 {
+
+  def method80_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { method80_2 }
+}
+
+
+object Object82_1 {
+
+  def method80_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { method80_2 } // trigger
+}
+
+
+trait Trait83_1 {
+
+  def method80_2 {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { method80_2 }
+}
+
+
+class Class85_1 {
+
+  val fun84_2 = () => {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { fun84_2() }
+}
+
+
+object Object86_1 {
+
+  val fun84_2 = () => {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { fun84_2() } // trigger
+}
+
+
+trait Trait87_1 {
+
+  val fun84_2 = () => {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { fun84_2() }
+}
+
+
+class Class89_1 {
+
+  class Class88_2 {
+    { // in primary constructor
+
+      trait Trait67_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Trait67_3 {}).run // trigger
+    }
+  }
+
+  def run { (new Class88_2) }
+}
+
+
+object Object90_1 {
+
+  class Class88_2 {
+    { // in primary constructor
+
+      trait Trait67_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Trait67_3 {}).run // trigger
+    }
+  }
+
+  def run { (new Class88_2) } // trigger
+}
+
+
+trait Trait91_1 {
+
+  class Class88_2 {
+    { // in primary constructor
+
+      trait Trait67_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        def run { runTest }
+      }
+
+      (new Trait67_3 {}).run // trigger
+    }
+  }
+
+  def run { (new Class88_2) }
+}
+
+
+class Class93_1 {
+
+  lazy val lzvalue92_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { lzvalue92_2 }
+}
+
+
+object Object94_1 {
+
+  lazy val lzvalue92_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { lzvalue92_2 } // trigger
+}
+
+
+trait Trait95_1 {
+
+  lazy val lzvalue92_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { lzvalue92_2 }
+}
+
+
+class Class97_1 {
+
+  val value96_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { value96_2 }
+}
+
+
+object Object98_1 {
+
+  val value96_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { value96_2 } // trigger
+}
+
+
+trait Trait99_1 {
+
+  val value96_2 = {
+
+    trait Trait67_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      def run { runTest }
+    }
+
+    (new Trait67_3 {}).run // trigger
+  }
+
+  def run { value96_2 }
+}
+
+
+class Class102_1 {
+
+  class Class101_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Class101_2).run }
+}
+
+
+object Object103_1 {
+
+  class Class101_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Class101_2).run } // trigger
+}
+
+
+trait Trait104_1 {
+
+  class Class101_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Class101_2).run }
+}
+
+
+class Class106_1 {
+
+  object Object105_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 } // trigger
+  }
+
+  def run { Object105_2.run }
+}
+
+
+object Object107_1 {
+
+  object Object105_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 } // trigger
+  }
+
+  def run { Object105_2.run } // trigger
+}
+
+
+trait Trait108_1 {
+
+  object Object105_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 } // trigger
+  }
+
+  def run { Object105_2.run }
+}
+
+
+class Class110_1 {
+
+  trait Trait109_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Trait109_2 {}).run }
+}
+
+
+object Object111_1 {
+
+  trait Trait109_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Trait109_2 {}).run } // trigger
+}
+
+
+trait Trait112_1 {
+
+  trait Trait109_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { method100_3 }
+  }
+
+  def run { (new Trait109_2 {}).run }
+}
+
+
+class Class114_1 {
+
+  def method113_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { method113_2 }
+}
+
+
+object Object115_1 {
+
+  def method113_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { method113_2 } // trigger
+}
+
+
+trait Trait116_1 {
+
+  def method113_2 {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { method113_2 }
+}
+
+
+class Class118_1 {
+
+  val fun117_2 = () => {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { fun117_2() }
+}
+
+
+object Object119_1 {
+
+  val fun117_2 = () => {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { fun117_2() } // trigger
+}
+
+
+trait Trait120_1 {
+
+  val fun117_2 = () => {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { fun117_2() }
+}
+
+
+class Class122_1 {
+
+  class Class121_2 {
+    { // in primary constructor
+
+      def method100_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      method100_3 // trigger
+    }
+  }
+
+  def run { (new Class121_2) }
+}
+
+
+object Object123_1 {
+
+  class Class121_2 {
+    { // in primary constructor
+
+      def method100_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      method100_3 // trigger
+    }
+  }
+
+  def run { (new Class121_2) } // trigger
+}
+
+
+trait Trait124_1 {
+
+  class Class121_2 {
+    { // in primary constructor
+
+      def method100_3 {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      method100_3 // trigger
+    }
+  }
+
+  def run { (new Class121_2) }
+}
+
+
+class Class126_1 {
+
+  lazy val lzvalue125_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { lzvalue125_2 }
+}
+
+
+object Object127_1 {
+
+  lazy val lzvalue125_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { lzvalue125_2 } // trigger
+}
+
+
+trait Trait128_1 {
+
+  lazy val lzvalue125_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { lzvalue125_2 }
+}
+
+
+class Class130_1 {
+
+  val value129_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { value129_2 }
+}
+
+
+object Object131_1 {
+
+  val value129_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { value129_2 } // trigger
+}
+
+
+trait Trait132_1 {
+
+  val value129_2 = {
+
+    def method100_3 {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    method100_3 // trigger
+  }
+
+  def run { value129_2 }
+}
+
+
+class Class135_1 {
+
+  class Class134_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Class134_2).run }
+}
+
+
+object Object136_1 {
+
+  class Class134_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Class134_2).run } // trigger
+}
+
+
+trait Trait137_1 {
+
+  class Class134_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Class134_2).run }
+}
+
+
+class Class139_1 {
+
+  object Object138_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() } // trigger
+  }
+
+  def run { Object138_2.run }
+}
+
+
+object Object140_1 {
+
+  object Object138_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() } // trigger
+  }
+
+  def run { Object138_2.run } // trigger
+}
+
+
+trait Trait141_1 {
+
+  object Object138_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() } // trigger
+  }
+
+  def run { Object138_2.run }
+}
+
+
+class Class143_1 {
+
+  trait Trait142_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Trait142_2 {}).run }
+}
+
+
+object Object144_1 {
+
+  trait Trait142_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Trait142_2 {}).run } // trigger
+}
+
+
+trait Trait145_1 {
+
+  trait Trait142_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { fun133_3() }
+  }
+
+  def run { (new Trait142_2 {}).run }
+}
+
+
+class Class147_1 {
+
+  def method146_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { method146_2 }
+}
+
+
+object Object148_1 {
+
+  def method146_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { method146_2 } // trigger
+}
+
+
+trait Trait149_1 {
+
+  def method146_2 {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { method146_2 }
+}
+
+
+class Class151_1 {
+
+  val fun150_2 = () => {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { fun150_2() }
+}
+
+
+object Object152_1 {
+
+  val fun150_2 = () => {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { fun150_2() } // trigger
+}
+
+
+trait Trait153_1 {
+
+  val fun150_2 = () => {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { fun150_2() }
+}
+
+
+class Class155_1 {
+
+  class Class154_2 {
+    { // in primary constructor
+
+      val fun133_3 = () => {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      fun133_3() // trigger
+    }
+  }
+
+  def run { (new Class154_2) }
+}
+
+
+object Object156_1 {
+
+  class Class154_2 {
+    { // in primary constructor
+
+      val fun133_3 = () => {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      fun133_3() // trigger
+    }
+  }
+
+  def run { (new Class154_2) } // trigger
+}
+
+
+trait Trait157_1 {
+
+  class Class154_2 {
+    { // in primary constructor
+
+      val fun133_3 = () => {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      fun133_3() // trigger
+    }
+  }
+
+  def run { (new Class154_2) }
+}
+
+
+class Class159_1 {
+
+  lazy val lzvalue158_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { lzvalue158_2 }
+}
+
+
+object Object160_1 {
+
+  lazy val lzvalue158_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { lzvalue158_2 } // trigger
+}
+
+
+trait Trait161_1 {
+
+  lazy val lzvalue158_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { lzvalue158_2 }
+}
+
+
+class Class163_1 {
+
+  val value162_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { value162_2 }
+}
+
+
+object Object164_1 {
+
+  val value162_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { value162_2 } // trigger
+}
+
+
+trait Trait165_1 {
+
+  val value162_2 = {
+
+    val fun133_3 = () => {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    fun133_3() // trigger
+  }
+
+  def run { value162_2 }
+}
+
+
+class Class168_1 {
+
+  class Class167_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Class167_2).run }
+}
+
+
+object Object169_1 {
+
+  class Class167_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Class167_2).run } // trigger
+}
+
+
+trait Trait170_1 {
+
+  class Class167_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Class167_2).run }
+}
+
+
+class Class172_1 {
+
+  object Object171_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) } // trigger
+  }
+
+  def run { Object171_2.run }
+}
+
+
+object Object173_1 {
+
+  object Object171_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) } // trigger
+  }
+
+  def run { Object171_2.run } // trigger
+}
+
+
+trait Trait174_1 {
+
+  object Object171_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) } // trigger
+  }
+
+  def run { Object171_2.run }
+}
+
+
+class Class176_1 {
+
+  trait Trait175_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Trait175_2 {}).run }
+}
+
+
+object Object177_1 {
+
+  trait Trait175_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Trait175_2 {}).run } // trigger
+}
+
+
+trait Trait178_1 {
+
+  trait Trait175_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    def run { (new Class166_3) }
+  }
+
+  def run { (new Trait175_2 {}).run }
+}
+
+
+class Class180_1 {
+
+  def method179_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { method179_2 }
+}
+
+
+object Object181_1 {
+
+  def method179_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { method179_2 } // trigger
+}
+
+
+trait Trait182_1 {
+
+  def method179_2 {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { method179_2 }
+}
+
+
+class Class184_1 {
+
+  val fun183_2 = () => {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { fun183_2() }
+}
+
+
+object Object185_1 {
+
+  val fun183_2 = () => {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { fun183_2() } // trigger
+}
+
+
+trait Trait186_1 {
+
+  val fun183_2 = () => {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { fun183_2() }
+}
+
+
+class Class188_1 {
+
+  class Class187_2 {
+    { // in primary constructor
+
+      class Class166_3 {
+        { // in primary constructor
+          var ObjCounter = 0
+
+          object Obj  { ObjCounter += 1}
+          Obj // one
+
+          def singleThreadedAccess(x: Any) = {
+            x == Obj
+          }
+
+          def runTest {
+            try {
+              assert(singleThreadedAccess(Obj))
+              assert(ObjCounter == 1)
+            } catch {
+              case e =>  print("failed "); e.printStackTrace()
+            }
+            println("ok")
+          }
+
+          runTest // trigger
+        }
+      }
+
+      (new Class166_3) // trigger
+    }
+  }
+
+  def run { (new Class187_2) }
+}
+
+
+object Object189_1 {
+
+  class Class187_2 {
+    { // in primary constructor
+
+      class Class166_3 {
+        { // in primary constructor
+          var ObjCounter = 0
+
+          object Obj  { ObjCounter += 1}
+          Obj // one
+
+          def singleThreadedAccess(x: Any) = {
+            x == Obj
+          }
+
+          def runTest {
+            try {
+              assert(singleThreadedAccess(Obj))
+              assert(ObjCounter == 1)
+            } catch {
+              case e =>  print("failed "); e.printStackTrace()
+            }
+            println("ok")
+          }
+
+          runTest // trigger
+        }
+      }
+
+      (new Class166_3) // trigger
+    }
+  }
+
+  def run { (new Class187_2) } // trigger
+}
+
+
+trait Trait190_1 {
+
+  class Class187_2 {
+    { // in primary constructor
+
+      class Class166_3 {
+        { // in primary constructor
+          var ObjCounter = 0
+
+          object Obj  { ObjCounter += 1}
+          Obj // one
+
+          def singleThreadedAccess(x: Any) = {
+            x == Obj
+          }
+
+          def runTest {
+            try {
+              assert(singleThreadedAccess(Obj))
+              assert(ObjCounter == 1)
+            } catch {
+              case e =>  print("failed "); e.printStackTrace()
+            }
+            println("ok")
+          }
+
+          runTest // trigger
+        }
+      }
+
+      (new Class166_3) // trigger
+    }
+  }
+
+  def run { (new Class187_2) }
+}
+
+
+class Class192_1 {
+
+  lazy val lzvalue191_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { lzvalue191_2 }
+}
+
+
+object Object193_1 {
+
+  lazy val lzvalue191_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { lzvalue191_2 } // trigger
+}
+
+
+trait Trait194_1 {
+
+  lazy val lzvalue191_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { lzvalue191_2 }
+}
+
+
+class Class196_1 {
+
+  val value195_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { value195_2 }
+}
+
+
+object Object197_1 {
+
+  val value195_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { value195_2 } // trigger
+}
+
+
+trait Trait198_1 {
+
+  val value195_2 = {
+
+    class Class166_3 {
+      { // in primary constructor
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+    }
+
+    (new Class166_3) // trigger
+  }
+
+  def run { value195_2 }
+}
+
+
+class Class201_1 {
+
+  class Class200_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Class200_2).run }
+}
+
+
+object Object202_1 {
+
+  class Class200_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Class200_2).run } // trigger
+}
+
+
+trait Trait203_1 {
+
+  class Class200_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Class200_2).run }
+}
+
+
+class Class205_1 {
+
+  object Object204_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 } // trigger
+  }
+
+  def run { Object204_2.run }
+}
+
+
+object Object206_1 {
+
+  object Object204_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 } // trigger
+  }
+
+  def run { Object204_2.run } // trigger
+}
+
+
+trait Trait207_1 {
+
+  object Object204_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 } // trigger
+  }
+
+  def run { Object204_2.run }
+}
+
+
+class Class209_1 {
+
+  trait Trait208_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Trait208_2 {}).run }
+}
+
+
+object Object210_1 {
+
+  trait Trait208_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Trait208_2 {}).run } // trigger
+}
+
+
+trait Trait211_1 {
+
+  trait Trait208_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { lzvalue199_3 }
+  }
+
+  def run { (new Trait208_2 {}).run }
+}
+
+
+class Class213_1 {
+
+  def method212_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { method212_2 }
+}
+
+
+object Object214_1 {
+
+  def method212_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { method212_2 } // trigger
+}
+
+
+trait Trait215_1 {
+
+  def method212_2 {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { method212_2 }
+}
+
+
+class Class217_1 {
+
+  val fun216_2 = () => {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { fun216_2() }
+}
+
+
+object Object218_1 {
+
+  val fun216_2 = () => {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { fun216_2() } // trigger
+}
+
+
+trait Trait219_1 {
+
+  val fun216_2 = () => {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { fun216_2() }
+}
+
+
+class Class221_1 {
+
+  class Class220_2 {
+    { // in primary constructor
+
+      lazy val lzvalue199_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      lzvalue199_3 // trigger
+    }
+  }
+
+  def run { (new Class220_2) }
+}
+
+
+object Object222_1 {
+
+  class Class220_2 {
+    { // in primary constructor
+
+      lazy val lzvalue199_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      lzvalue199_3 // trigger
+    }
+  }
+
+  def run { (new Class220_2) } // trigger
+}
+
+
+trait Trait223_1 {
+
+  class Class220_2 {
+    { // in primary constructor
+
+      lazy val lzvalue199_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      lzvalue199_3 // trigger
+    }
+  }
+
+  def run { (new Class220_2) }
+}
+
+
+class Class225_1 {
+
+  lazy val lzvalue224_2 = {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { lzvalue224_2 }
+}
+
+
+object Object226_1 {
+
+  lazy val lzvalue224_2 = {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { lzvalue224_2 } // trigger
+}
+
+
+trait Trait227_1 {
+
+  lazy val lzvalue224_2 = {
+
+    lazy val lzvalue199_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    lzvalue199_3 // trigger
+  }
+
+  def run { lzvalue224_2 }
+}
+
+
+
+class Class234_1 {
+
+  class Class233_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Class233_2).run }
+}
+
+
+object Object235_1 {
+
+  class Class233_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Class233_2).run } // trigger
+}
+
+
+trait Trait236_1 {
+
+  class Class233_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Class233_2).run }
+}
+
+
+class Class238_1 {
+
+  object Object237_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 } // trigger
+  }
+
+  def run { Object237_2.run }
+}
+
+
+object Object239_1 {
+
+  object Object237_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 } // trigger
+  }
+
+  def run { Object237_2.run } // trigger
+}
+
+
+trait Trait240_1 {
+
+  object Object237_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 } // trigger
+  }
+
+  def run { Object237_2.run }
+}
+
+
+class Class242_1 {
+
+  trait Trait241_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Trait241_2 {}).run }
+}
+
+
+object Object243_1 {
+
+  trait Trait241_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Trait241_2 {}).run } // trigger
+}
+
+
+trait Trait244_1 {
+
+  trait Trait241_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    def run { value232_3 }
+  }
+
+  def run { (new Trait241_2 {}).run }
+}
+
+
+class Class246_1 {
+
+  def method245_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { method245_2 }
+}
+
+
+object Object247_1 {
+
+  def method245_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { method245_2 } // trigger
+}
+
+
+trait Trait248_1 {
+
+  def method245_2 {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { method245_2 }
+}
+
+
+class Class250_1 {
+
+  val fun249_2 = () => {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { fun249_2() }
+}
+
+
+object Object251_1 {
+
+  val fun249_2 = () => {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { fun249_2() } // trigger
+}
+
+
+trait Trait252_1 {
+
+  val fun249_2 = () => {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { fun249_2() }
+}
+
+
+class Class254_1 {
+
+  class Class253_2 {
+    { // in primary constructor
+
+      val value232_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      value232_3 // trigger
+    }
+  }
+
+  def run { (new Class253_2) }
+}
+
+
+object Object255_1 {
+
+  class Class253_2 {
+    { // in primary constructor
+
+      val value232_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      value232_3 // trigger
+    }
+  }
+
+  def run { (new Class253_2) } // trigger
+}
+
+
+trait Trait256_1 {
+
+  class Class253_2 {
+    { // in primary constructor
+
+      val value232_3 = {
+        var ObjCounter = 0
+
+        object Obj  { ObjCounter += 1}
+        Obj // one
+
+        def singleThreadedAccess(x: Any) = {
+          x == Obj
+        }
+
+        def runTest {
+          try {
+            assert(singleThreadedAccess(Obj))
+            assert(ObjCounter == 1)
+          } catch {
+            case e =>  print("failed "); e.printStackTrace()
+          }
+          println("ok")
+        }
+
+        runTest // trigger
+      }
+
+      value232_3 // trigger
+    }
+  }
+
+  def run { (new Class253_2) }
+}
+
+
+class Class258_1 {
+
+  lazy val lzvalue257_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { lzvalue257_2 }
+}
+
+
+object Object259_1 {
+
+  lazy val lzvalue257_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { lzvalue257_2 } // trigger
+}
+
+
+trait Trait260_1 {
+
+  lazy val lzvalue257_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { lzvalue257_2 }
+}
+
+
+class Class262_1 {
+
+  val value261_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { value261_2 }
+}
+
+
+object Object263_1 {
+
+  val value261_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { value261_2 } // trigger
+}
+
+
+trait Trait264_1 {
+
+  val value261_2 = {
+
+    val value232_3 = {
+      var ObjCounter = 0
+
+      object Obj  { ObjCounter += 1}
+      Obj // one
+
+      def singleThreadedAccess(x: Any) = {
+        x == Obj
+      }
+
+      def runTest {
+        try {
+          assert(singleThreadedAccess(Obj))
+          assert(ObjCounter == 1)
+        } catch {
+          case e =>  print("failed "); e.printStackTrace()
+        }
+        println("ok")
+      }
+
+      runTest // trigger
+    }
+
+    value232_3 // trigger
+  }
+
+  def run { value261_2 }
+}
+
+
+object Test extends App {
+  (new Class3_1).run
+  Object4_1.run
+  (new Trait5_1 {}).run
+  (new Class7_1).run
+  Object8_1.run
+  (new Trait9_1 {}).run
+  (new Class11_1).run
+  Object12_1.run
+  (new Trait13_1 {}).run
+  (new Class15_1).run
+  Object16_1.run
+  (new Trait17_1 {}).run
+  (new Class19_1).run
+  Object20_1.run
+  (new Trait21_1 {}).run
+  (new Class23_1).run
+  Object24_1.run
+  (new Trait25_1 {}).run
+  (new Class27_1).run
+  Object28_1.run
+  (new Trait29_1 {}).run
+  (new Class31_1).run
+  Object32_1.run
+  (new Trait33_1 {}).run
+  (new Class36_1).run
+  Object37_1.run
+  (new Trait38_1 {}).run
+  (new Class40_1).run
+  Object41_1.run
+  (new Trait42_1 {}).run
+  (new Class44_1).run
+  Object45_1.run
+  (new Trait46_1 {}).run
+  (new Class48_1).run
+  Object49_1.run
+  (new Trait50_1 {}).run
+  (new Class52_1).run
+  Object53_1.run
+  (new Trait54_1 {}).run
+  (new Class56_1).run
+  Object57_1.run
+  (new Trait58_1 {}).run
+  (new Class60_1).run
+  Object61_1.run
+  (new Trait62_1 {}).run
+  (new Class64_1).run
+  Object65_1.run
+  (new Trait66_1 {}).run
+  (new Class69_1).run
+  Object70_1.run
+  (new Trait71_1 {}).run
+  (new Class73_1).run
+  Object74_1.run
+  (new Trait75_1 {}).run
+  (new Class77_1).run
+  Object78_1.run
+  (new Trait79_1 {}).run
+  (new Class81_1).run
+  Object82_1.run
+  (new Trait83_1 {}).run
+  (new Class85_1).run
+  Object86_1.run
+  (new Trait87_1 {}).run
+  (new Class89_1).run
+  Object90_1.run
+  (new Trait91_1 {}).run
+  (new Class93_1).run
+  Object94_1.run
+  (new Trait95_1 {}).run
+  (new Class97_1).run
+  Object98_1.run
+  (new Trait99_1 {}).run
+  (new Class102_1).run
+  Object103_1.run
+  (new Trait104_1 {}).run
+  (new Class106_1).run
+  Object107_1.run
+  (new Trait108_1 {}).run
+  (new Class110_1).run
+  Object111_1.run
+  (new Trait112_1 {}).run
+  (new Class114_1).run
+  Object115_1.run
+  (new Trait116_1 {}).run
+  (new Class118_1).run
+  Object119_1.run
+  (new Trait120_1 {}).run
+  (new Class122_1).run
+  Object123_1.run
+  (new Trait124_1 {}).run
+  (new Class126_1).run
+  Object127_1.run
+  (new Trait128_1 {}).run
+  (new Class130_1).run
+  Object131_1.run
+  (new Trait132_1 {}).run
+  (new Class135_1).run
+  Object136_1.run
+  (new Trait137_1 {}).run
+  (new Class139_1).run
+  Object140_1.run
+  (new Trait141_1 {}).run
+  (new Class143_1).run
+  Object144_1.run
+  (new Trait145_1 {}).run
+  (new Class147_1).run
+  Object148_1.run
+  (new Trait149_1 {}).run
+  (new Class151_1).run
+  Object152_1.run
+  (new Trait153_1 {}).run
+  (new Class155_1).run
+  Object156_1.run
+  (new Trait157_1 {}).run
+  (new Class159_1).run
+  Object160_1.run
+  (new Trait161_1 {}).run
+  (new Class163_1).run
+  Object164_1.run
+  (new Trait165_1 {}).run
+  (new Class168_1).run
+  Object169_1.run
+  (new Trait170_1 {}).run
+  (new Class172_1).run
+  Object173_1.run
+  (new Trait174_1 {}).run
+  (new Class176_1).run
+  Object177_1.run
+  (new Trait178_1 {}).run
+  (new Class180_1).run
+  Object181_1.run
+  (new Trait182_1 {}).run
+  (new Class184_1).run
+  Object185_1.run
+  (new Trait186_1 {}).run
+  (new Class188_1).run
+  Object189_1.run
+  (new Trait190_1 {}).run
+  (new Class192_1).run
+  Object193_1.run
+  (new Trait194_1 {}).run
+  (new Class196_1).run
+  Object197_1.run
+  (new Trait198_1 {}).run
+  (new Class201_1).run
+  Object202_1.run
+  (new Trait203_1 {}).run
+  (new Class205_1).run
+  Object206_1.run
+  (new Trait207_1 {}).run
+  (new Class209_1).run
+  Object210_1.run
+  (new Trait211_1 {}).run
+  (new Class213_1).run
+  Object214_1.run
+  (new Trait215_1 {}).run
+  (new Class217_1).run
+  Object218_1.run
+  (new Trait219_1 {}).run
+  (new Class221_1).run
+  Object222_1.run
+  (new Trait223_1 {}).run
+  (new Class225_1).run
+  Object226_1.run
+  (new Trait227_1 {}).run
+  (new Class234_1).run
+  Object235_1.run
+  (new Trait236_1 {}).run
+  (new Class238_1).run
+  Object239_1.run
+  (new Trait240_1 {}).run
+  (new Class242_1).run
+  Object243_1.run
+  (new Trait244_1 {}).run
+  (new Class246_1).run
+  Object247_1.run
+  (new Trait248_1 {}).run
+  (new Class250_1).run
+  Object251_1.run
+  (new Trait252_1 {}).run
+  (new Class254_1).run
+  Object255_1.run
+  (new Trait256_1 {}).run
+  (new Class258_1).run
+  Object259_1.run
+  (new Trait260_1 {}).run
+  (new Class262_1).run
+  Object263_1.run
+  (new Trait264_1 {}).run
+}
+