diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index 03197059a86..5abdb9058f1 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
@@ -860,15 +860,21 @@ public class JetControlFlowProcessor {
             JetMultiDeclaration multiDeclaration = expression.getMultiParameter();
             JetExpression loopRange = expression.getLoopRange();
 
-            JetType loopRangeType = trace.get(BindingContext.EXPRESSION_TYPE, loopRange);
-            TypePredicate loopRangeTypeSet = loopRangeType != null ? new SingleType(loopRangeType) : AllTypes.instance$;
-            PseudoValue loopRangeValue = builder.getBoundValue(loopRange);
+            TypePredicate loopRangeTypePredicate = AllTypes.instance$;
+            ResolvedCall<?> iteratorResolvedCall = trace.get(BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, loopRange);
+            if (iteratorResolvedCall != null) {
+                ReceiverValue iteratorReceiver = getExplicitReceiverValue(iteratorResolvedCall);
+                if (iteratorReceiver.exists()) {
+                    loopRangeTypePredicate = PseudocodePackage.getReceiverTypePredicate(iteratorResolvedCall, iteratorReceiver);
+                }
+            }
 
+            PseudoValue loopRangeValue = builder.getBoundValue(loopRange);
             PseudoValue value = builder.magic(
                     loopRange != null ? loopRange : expression,
                     null,
                     Collections.singletonList(loopRangeValue),
-                    Collections.singletonMap(loopRangeValue, loopRangeTypeSet),
+                    Collections.singletonMap(loopRangeValue, loopRangeTypePredicate),
                     true
             ).getOutputValue();
 
@@ -882,6 +888,17 @@ public class JetControlFlowProcessor {
             }
         }
 
+        private ReceiverValue getExplicitReceiverValue(ResolvedCall<?> resolvedCall) {
+            switch(resolvedCall.getExplicitReceiverKind()) {
+                case THIS_OBJECT:
+                    return resolvedCall.getThisObject();
+                case RECEIVER_ARGUMENT:
+                    return resolvedCall.getReceiverArgument();
+                default:
+                    return ReceiverValue.NO_RECEIVER;
+            }
+        }
+
         @Override
         public void visitBreakExpression(@NotNull JetBreakExpression expression) {
             JetElement loop = getCorrespondingLoop(expression);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt
index ac4bd2030cb..60aea47a0e1 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt
@@ -32,12 +32,48 @@ public data class SingleType(val targetType: JetType): TypePredicate {
     override fun toString(): String = targetType.render()
 }
 
+public data class AllSubtypes(val upperBound: JetType): TypePredicate {
+    override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.INSTANCE.isSubtypeOf(typeToCheck, upperBound)
+
+    override fun toString(): String = "{<: ${upperBound.render()}}"
+}
+
+public data class ForAllTypes(val typeSets: List<TypePredicate>): TypePredicate {
+    override fun invoke(typeToCheck: JetType): Boolean = typeSets.all { it(typeToCheck) }
+
+    override fun toString(): String = "AND{${typeSets.makeString(", ")}}"
+}
+
+public data class ForSomeType(val typeSets: List<TypePredicate>): TypePredicate {
+    override fun invoke(typeToCheck: JetType): Boolean = typeSets.any { it(typeToCheck) }
+
+    override fun toString(): String = "OR{${typeSets.makeString(", ")}}"
+}
+
 public object AllTypes : TypePredicate {
     override fun invoke(typeToCheck: JetType): Boolean = true
 
-    override fun toString(): String = ""
+    override fun toString(): String = "*"
 }
 
+// todo: simplify computed type predicate when possible
+fun and(predicates: Collection<TypePredicate>): TypePredicate =
+        when (predicates.size) {
+            0 -> AllTypes
+            1 -> predicates.first()
+            else -> ForAllTypes(predicates.toList())
+        }
+
+fun or(predicates: Collection<TypePredicate>): TypePredicate? =
+        when (predicates.size) {
+            0 -> null
+            1 -> predicates.first()
+            else -> ForSomeType(predicates.toList())
+        }
+
+fun JetType.getSubtypesPredicate(): TypePredicate? =
+        if (TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, this)) AllSubtypes(this) else SingleType(this)
+
 private fun JetType.render(): String = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this)
 
 public fun <T> TypePredicate.expectedTypeFor(keys: Iterable<T>): Map<T, TypePredicate> =
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/pseudocodeUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/pseudocodeUtil.kt
index 01871a57938..41e3886f47b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/pseudocodeUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/pseudocodeUtil.kt
@@ -16,13 +16,21 @@
 
 package org.jetbrains.jet.lang.cfg.pseudocode
 
-import org.jetbrains.jet.lang.psi.JetExpression
-import org.jetbrains.jet.lang.cfg.pseudocodeTraverser.traverseFollowingInstructions
-import java.util.HashSet
-import org.jetbrains.jet.lang.cfg.pseudocodeTraverser.TraversalOrder
-import org.jetbrains.jet.lang.psi.JetFunction
-import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
-import org.jetbrains.jet.lang.psi.JetFunctionLiteral
+import org.jetbrains.jet.lang.cfg.pseudocodeTraverser.*
+import org.jetbrains.jet.lang.cfg.pseudocode.instructions.*
+import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.*
+import org.jetbrains.jet.lang.cfg.pseudocode.instructions.jumps.*
+import org.jetbrains.jet.lang.psi.*
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.resolve.bindingContextUtil.*
+import org.jetbrains.jet.lang.resolve.calls.model.*
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+import org.jetbrains.jet.lang.resolve.BindingContext
+import java.util.*
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.jet.lang.resolve.OverridingUtil
+import org.jetbrains.jet.lang.types.TypeUtils
+import org.jetbrains.jet.lang.types.JetType
 
 fun JetExpression.isStatement(pseudocode: Pseudocode): Boolean {
     val value = pseudocode.getElementValue(this);
@@ -32,7 +40,7 @@ fun JetExpression.isStatement(pseudocode: Pseudocode): Boolean {
         return when {
             (getParent() as? JetFunction)?.getBodyExpression() == this ->
                 true
-            pseudocode.getElementValue(getParentByType(javaClass<JetFunctionLiteral>())?.getBodyExpression()) == value ->
+            value.implicitReturnValue ->
                 true
             else ->
                 false
@@ -42,4 +50,127 @@ fun JetExpression.isStatement(pseudocode: Pseudocode): Boolean {
     val instruction = value.createdAt
     if (considerUsedIfCreatedBeforeExit() && instruction.nextInstructions.any { it == pseudocode.getExitInstruction() }) return false
     return traverseFollowingInstructions(instruction, HashSet(), TraversalOrder.FORWARD) { value !in it.inputValues }
+}
+
+val PseudoValue.implicitReturnValue: Boolean
+    get() {
+        val pseudocode = createdAt.owner
+
+        val function = pseudocode.getCorrespondingElement() as? JetDeclarationWithBody
+
+        if (function is JetFunctionLiteral || (function != null && !function.hasBlockBody())) {
+            return pseudocode.getElementValue(function.getBodyExpression()) == this
+        }
+        return false
+    }
+
+fun Pseudocode.collectValueUsages(): Map<PseudoValue, List<Instruction>> {
+    val map = HashMap<PseudoValue, MutableList<Instruction>>()
+    traverseFollowingInstructions(getEnterInstruction(), HashSet(), TraversalOrder.FORWARD) {
+        for (value in it.inputValues) {
+            map.getOrPut(value){ ArrayList() }.add(it)
+        }
+        true
+    }
+
+    return map
+}
+
+fun getReceiverTypePredicate(resolvedCall: ResolvedCall<*>, receiverValue: ReceiverValue): TypePredicate? {
+    val callableDescriptor = resolvedCall.getResultingDescriptor()
+    if (callableDescriptor == null) return null
+
+    when (receiverValue) {
+        resolvedCall.getReceiverArgument() -> {
+            val receiverParameter = callableDescriptor.getReceiverParameter()
+            if (receiverParameter != null) return receiverParameter.getType().getSubtypesPredicate()
+        }
+        resolvedCall.getThisObject() -> {
+            val rootCallableDescriptors = OverridingUtil.getTopmostOverridenDescriptors(callableDescriptor)
+            return or(rootCallableDescriptors.map {
+                it.getExpectedThisObject()?.getType()?.let { TypeUtils.makeNullableIfNeeded(it, resolvedCall.isSafeCall()) }?.getSubtypesPredicate()
+            }.filterNotNull())
+        }
+    }
+
+    return null
+}
+
+fun getExpectedTypePredicate(
+        value: PseudoValue,
+        valueUsageMap: Map<PseudoValue, List<Instruction>>,
+        bindingContext: BindingContext
+): TypePredicate {
+    val typePredicates = HashSet<TypePredicate?>()
+
+    fun addSubtypesOf(jetType: JetType?) = typePredicates.add(jetType?.getSubtypesPredicate())
+
+    fun addTypePredicates(value: PseudoValue) {
+        if (value.implicitReturnValue) {
+            val function = value.createdAt.owner.getCorrespondingElement() as? JetDeclarationWithBody
+            val functionDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor
+            addSubtypesOf(functionDescriptor?.getReturnType())
+        }
+
+        valueUsageMap[value]?.forEach {
+            when (it) {
+                is ReturnValueInstruction -> {
+                    val functionDescriptor = (it.element as JetReturnExpression).getTargetFunctionDescriptor(bindingContext)
+                    addSubtypesOf(functionDescriptor?.getReturnType())
+                }
+
+                is ConditionalJumpInstruction ->
+                    addSubtypesOf(KotlinBuiltIns.getInstance().getBooleanType())
+
+                is ThrowExceptionInstruction ->
+                    addSubtypesOf(KotlinBuiltIns.getInstance().getThrowable().getDefaultType())
+
+                is MergeInstruction ->
+                    addTypePredicates(it.outputValue)
+
+                is AccessValueInstruction -> {
+                    val accessTarget = it.target
+                    val receiverValue = it.receiverValues[value]
+                    if (receiverValue != null) {
+                        typePredicates.add(getReceiverTypePredicate((accessTarget as AccessTarget.Call).resolvedCall, receiverValue))
+                    }
+                    else {
+                        val expectedType = when (accessTarget) {
+                            is AccessTarget.Call ->
+                                (accessTarget.resolvedCall.getResultingDescriptor() as? VariableDescriptor)?.getType()
+                            is AccessTarget.Declaration ->
+                                accessTarget.descriptor.getType()
+                            else ->
+                                null
+                        }
+                        addSubtypesOf(expectedType)
+                    }
+                }
+
+                is CallInstruction -> {
+                    val receiverValue = it.receiverValues[value]
+                    if (receiverValue != null) {
+                        typePredicates.add(getReceiverTypePredicate(it.resolvedCall, receiverValue))
+                    }
+                    else {
+                        it.arguments[value]?.let { parameter ->
+                            val expectedType = when (it.resolvedCall.getValueArguments()[parameter]) {
+                                is VarargValueArgument ->
+                                    parameter.getVarargElementType()
+                                else ->
+                                    parameter.getType()
+                            }
+                            addSubtypesOf(expectedType)
+                        }
+                    }
+                }
+
+                is MagicInstruction ->
+                    typePredicates.add(it.expectedTypes[value])
+            }
+        }
+    }
+
+    addTypePredicates(value)
+    return and(typePredicates.filterNotNull())
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.kt
index 2ab6943670f..1841ed6dfd7 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.kt
@@ -21,14 +21,18 @@ import org.jetbrains.jet.lang.psi.Call
 import org.jetbrains.jet.lang.psi.JetPsiUtil
 import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.lang.psi.JetQualifiedExpression
-import org.jetbrains.jet.lang.psi.JetBinaryExpression
-import org.jetbrains.jet.lang.psi.JetUnaryExpression
-import org.jetbrains.jet.lang.psi.JetArrayAccessExpression
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.JetOperationExpression
 import org.jetbrains.jet.lang.resolve.BindingContext.CALL
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
+import org.jetbrains.jet.lang.psi.JetReturnExpression
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
+import org.jetbrains.jet.lang.resolve.BindingContext.LABEL_TARGET
+import org.jetbrains.jet.lang.resolve.BindingContext.FUNCTION
+import org.jetbrains.jet.lang.resolve.BindingContext.DECLARATION_TO_DESCRIPTOR
+import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
+import org.jetbrains.jet.lang.psi.JetDeclarationWithBody
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor
 
 /**
  *  For expressions like <code>a(), a[i], a.b.c(), +a, a + b, (a()), a(): Int, @label a()</code>
@@ -51,3 +55,16 @@ fun JetExpression.getCorrespondingCall(bindingContext: BindingContext): Call? {
     }
     return bindingContext[CALL, reference]
 }
+
+public fun JetReturnExpression.getTargetFunctionDescriptor(bindingContext: BindingContext): FunctionDescriptor? {
+    val targetLabel = getTargetLabel()
+    if (targetLabel != null) return bindingContext[LABEL_TARGET, targetLabel]?.let { bindingContext[FUNCTION, it] }
+
+    val declarationDescriptor = bindingContext[DECLARATION_TO_DESCRIPTOR, getParentByType(javaClass<JetDeclarationWithBody>())]
+    val containingFunctionDescriptor = DescriptorUtils.getParentOfType(declarationDescriptor, javaClass<FunctionDescriptor>(), false)
+    if (containingFunctionDescriptor == null) return null
+
+    return stream(containingFunctionDescriptor) { DescriptorUtils.getParentOfType(it, javaClass<FunctionDescriptor>()) }
+            .dropWhile { it is AnonymousFunctionDescriptor }
+            .firstOrNull()
+}
diff --git a/compiler/testData/cfg-variables/basic/IfWithUninitialized.values b/compiler/testData/cfg-variables/basic/IfWithUninitialized.values
index 886eac6e86c..9e8d37ccb96 100644
--- a/compiler/testData/cfg-variables/basic/IfWithUninitialized.values
+++ b/compiler/testData/cfg-variables/basic/IfWithUninitialized.values
@@ -9,18 +9,18 @@ fun foo() {
     }
 }
 ---------------------
-1                                                            <v0>   NEW()          
-2                                                            <v1>   NEW()
-1 < 2                                                        <v2>   NEW(<v0>, <v1>)
-b                                                            <v3>   NEW()          
-use(b)                                                       <v4>   NEW(<v3>)
-{ use(b) }                                                   <v4>   COPY           
-true                                                         <v5>   NEW()          
-if (1 < 2) { use(b) } else { b = true }                      <v4>   COPY           
-{ val b: Boolean if (1 < 2) { use(b) } else { b = true } }   <v4>   COPY           
+1                                                            <v0>: {<: Comparable<Int>}   NEW()          
+2                                                            <v1>: Int                    NEW()          
+1 < 2                                                        <v2>: Boolean                NEW(<v0>, <v1>)
+b                                                            <v3>: {<: Any?}              NEW()          
+use(b)                                                       <v4>: *                      NEW(<v3>)      
+{ use(b) }                                                   <v4>: *                      COPY           
+true                                                         <v5>: Boolean                NEW()          
+if (1 < 2) { use(b) } else { b = true }                      <v4>: *                      COPY           
+{ val b: Boolean if (1 < 2) { use(b) } else { b = true } }   <v4>: *                      COPY           
 =====================
 == use ==
 fun use(vararg a: Any?) = a
 ---------------------
-a   <v1>   NEW()
+a   <v1>: {<: Array<Any?>}   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/basic/InitializedNotDeclared.values b/compiler/testData/cfg-variables/basic/InitializedNotDeclared.values
index 13de2c9986d..6b99c7aaf59 100644
--- a/compiler/testData/cfg-variables/basic/InitializedNotDeclared.values
+++ b/compiler/testData/cfg-variables/basic/InitializedNotDeclared.values
@@ -6,5 +6,5 @@ class A {
     val x: Int
 }
 ---------------------
-1   <v1>   NEW()
+1   <v1>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.values b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.values
index c7195b6fb36..4c2009adf92 100644
--- a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.values
+++ b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.values
@@ -7,8 +7,8 @@ fun foo() {
     }
 }
 ---------------------
-1                                      <v0>   NEW()
-{ (x: Int) -> val y = x + a use(a) }   <v1>   NEW()
+1                                      <v0>: Int                         NEW()
+{ (x: Int) -> val y = x + a use(a) }   <v1>: {<: (Int) -> Array<Any?>}   NEW()
 =====================
 == anonymous_0 ==
 { (x: Int) ->
@@ -16,15 +16,15 @@ fun foo() {
         use(a)
     }
 ---------------------
-x                      <v1>   NEW()
-a                      <v2>   NEW()
-x + a                  <v3>   NEW(<v1>, <v2>)
-a                      <v4>   NEW()          
-use(a)                 <v5>   NEW(<v4>)
-val y = x + a use(a)   <v5>   COPY           
+x                      <v1>: Int                NEW()
+a                      <v2>: Int                NEW()
+x + a                  <v3>: Int                NEW(<v1>, <v2>)
+a                      <v4>: {<: Any?}          NEW()
+use(a)                 <v5>: {<: Array<Any?>}   NEW(<v4>)
+val y = x + a use(a)   <v5>: {<: Array<Any?>}   COPY
 =====================
 == use ==
 fun use(vararg a: Any?) = a
 ---------------------
-a   <v1>   NEW()
+a   <v1>: {<: Array<Any?>}   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/basic/VariablesInitialization.values b/compiler/testData/cfg-variables/basic/VariablesInitialization.values
index 4288c843063..99f30cf9766 100644
--- a/compiler/testData/cfg-variables/basic/VariablesInitialization.values
+++ b/compiler/testData/cfg-variables/basic/VariablesInitialization.values
@@ -6,10 +6,10 @@ fun foo() {
     42
 }
 ---------------------
-1                                   <v0>   NEW()
-2                                   <v1>   NEW()
-42                                  <v2>   NEW()
-{ val a = 1 val b: Int b = 2 42 }   <v2>   COPY 
+1                                   <v0>: Int   NEW()
+2                                   <v1>: Int   NEW()
+42                                  <v2>: *     NEW()
+{ val a = 1 val b: Int b = 2 42 }   <v2>: *     COPY 
 =====================
 == bar ==
 fun bar(foo: Foo) {
@@ -18,13 +18,13 @@ fun bar(foo: Foo) {
     42
 }
 ---------------------
-foo                      <v1>   NEW()
-c                        <v2>   NEW(<v1>)
-foo.c                    <v2>   COPY     
-foo                      <v3>   NEW()
-2                        <v4>   NEW()
-42                       <v5>   NEW()    
-{ foo.c foo.c = 2 42 }   <v5>   COPY     
+foo                      <v1>: {<: Foo}   NEW()    
+c                        <v2>: *          NEW(<v1>)
+foo.c                    <v2>: *          COPY     
+foo                      <v3>: {<: Foo}   NEW()    
+2                        <v4>: Int        NEW()    
+42                       <v5>: *          NEW()    
+{ foo.c foo.c = 2 42 }   <v5>: *          COPY     
 =====================
 == Foo ==
 trait Foo {
diff --git a/compiler/testData/cfg-variables/basic/VariablesUsage.values b/compiler/testData/cfg-variables/basic/VariablesUsage.values
index f9713ca80ce..99496514298 100644
--- a/compiler/testData/cfg-variables/basic/VariablesUsage.values
+++ b/compiler/testData/cfg-variables/basic/VariablesUsage.values
@@ -6,13 +6,13 @@ fun foo() {
     use(a)
 }
 ---------------------
-1                                   <v0>   NEW()    
-a                                   <v1>   NEW()
-use(a)                              <v2>   NEW(<v1>)
-2                                   <v3>   NEW()    
-a                                   <v4>   NEW()
-use(a)                              <v5>   NEW(<v4>)
-{ var a = 1 use(a) a = 2 use(a) }   <v5>   COPY     
+1                                   <v0>: Int   NEW()    
+a                                   <v1>: Int   NEW()    
+use(a)                              <v2>: *     NEW(<v1>)
+2                                   <v3>: Int   NEW()    
+a                                   <v4>: Int   NEW()    
+use(a)                              <v5>: *     NEW(<v4>)
+{ var a = 1 use(a) a = 2 use(a) }   <v5>: *     COPY     
 =====================
 == bar ==
 fun bar() {
@@ -20,10 +20,10 @@ fun bar() {
     b = 3
 }
 ---------------------
-3   <v0>   NEW()
+3   <v0>: Int   NEW()
 =====================
 == use ==
 fun use(a: Int) = a
 ---------------------
-a   <v1>   NEW()
+a   <v1>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
index 0dfc529f7e4..2c25e090ff8 100644
--- a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
+++ b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
@@ -5,21 +5,21 @@ class TestFunctionLiteral {
     }
 }
 ---------------------
-{ (x: Int) -> sum(x - 1) + x }   <v0>   NEW()
+{ (x: Int) -> sum(x - 1) + x }   <v0>: {<: (Int) -> Int}   NEW()
 =====================
 == anonymous_0 ==
 { (x: Int) ->
         sum(x - 1) + x
     }
 ---------------------
-sum              <v2>   NEW(<v1>)
-x                <v3>   NEW()
-1                <v4>   NEW()
-x - 1            <v5>   NEW(<v3>, <v4>)
-sum(x - 1)       <v6>   NEW(<v2>, <v5>)
-x                <v7>   NEW()
-sum(x - 1) + x   <v8>   NEW(<v6>, <v7>)
-sum(x - 1) + x   <v8>   COPY
+sum              <v2>: {<: (Int) -> Int}   NEW(<v1>)      
+x                <v3>: Int                 NEW()          
+1                <v4>: Int                 NEW()          
+x - 1            <v5>: Int                 NEW(<v3>, <v4>)
+sum(x - 1)       <v6>: Int                 NEW(<v2>, <v5>)
+x                <v7>: Int                 NEW()          
+sum(x - 1) + x   <v8>: Int                 NEW(<v6>, <v7>)
+sum(x - 1) + x   <v8>: Int                 COPY           
 =====================
 == A ==
 open class A(val a: A)
@@ -37,23 +37,23 @@ class TestObjectLiteral {
     }
 }
 ---------------------
-obj                                                            <v1>   NEW(<v0>)
-obj                                                            <v3>   NEW(<v2>)
-object: A(obj) { { val x = obj } fun foo() { val y = obj } }   <v4>   NEW()
+obj                                                            <v1>: *        NEW(<v0>)
+obj                                                            <v3>: {<: A}   NEW(<v2>)
+object: A(obj) { { val x = obj } fun foo() { val y = obj } }   <v4>: {<: A}   NEW()    
 =====================
 == foo ==
 fun foo() {
             val y = obj
         }
 ---------------------
-obj   <v1>   NEW(<v0>)
+obj   <v1>: {<: A}   NEW(<v0>)
 =====================
 == TestOther ==
 class TestOther {
     val x: Int = x + 1
 }
 ---------------------
-x       <v1>   NEW(<v0>)
-1       <v2>   NEW()
-x + 1   <v3>   NEW(<v1>, <v2>)
+x       <v1>: Int   NEW(<v0>)      
+1       <v2>: Int   NEW()          
+x + 1   <v3>: Int   NEW(<v1>, <v2>)
 =====================
diff --git a/compiler/testData/cfg-variables/bugs/varInitializationInIf.values b/compiler/testData/cfg-variables/bugs/varInitializationInIf.values
index d87c23dbb1c..e14fe8f08f1 100644
--- a/compiler/testData/cfg-variables/bugs/varInitializationInIf.values
+++ b/compiler/testData/cfg-variables/bugs/varInitializationInIf.values
@@ -10,12 +10,12 @@ fun foo() {
     use(b)
 }
 ---------------------
-1                                                                      <v0>   NEW()
-2                                                                      <v1>   NEW()
-1 < 2                                                                  <v2>   NEW(<v0>, <v1>)
-false                                                                  <v3>   NEW()
-true                                                                   <v4>   NEW()
-b                                                                      <v5>   NEW()
-use(b)                                                                 <v6>   NEW(<v5>)
-{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) }   <v6>   COPY           
+1                                                                      <v0>: {<: Comparable<Int>}   NEW()          
+2                                                                      <v1>: Int                    NEW()          
+1 < 2                                                                  <v2>: Boolean                NEW(<v0>, <v1>)
+false                                                                  <v3>: Boolean                NEW()          
+true                                                                   <v4>: Boolean                NEW()          
+b                                                                      <v5>: *                      NEW()          
+use(b)                                                                 <v6>: *                      NEW(<v5>)      
+{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) }   <v6>: *                      COPY           
 =====================
diff --git a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values
index 5719f3b7cfe..4b4eee75d7b 100644
--- a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values
+++ b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values
@@ -13,17 +13,17 @@ fun foo(numbers: Collection<Int>) {
     }
 }
 ---------------------
-numbers   <v1>   NEW()
-1         <v3>   NEW()
-2         <v4>   NEW()
-1 < 2     <v5>   NEW(<v3>, <v4>)
-false     <v6>   NEW()
-true      <v7>   NEW()
-b         <v8>   NEW()
-use(b)    <v9>   NEW(<v8>)
+numbers   <v1>: {<: Iterable<Int>}     NEW()          
+1         <v3>: {<: Comparable<Int>}   NEW()          
+2         <v4>: Int                    NEW()          
+1 < 2     <v5>: Boolean                NEW(<v3>, <v4>)
+false     <v6>: Boolean                NEW()          
+true      <v7>: Boolean                NEW()          
+b         <v8>: {<: Any?}              NEW()          
+use(b)    <v9>: *                      NEW(<v8>)      
 =====================
 == use ==
 fun use(vararg a: Any?) = a
 ---------------------
-a   <v1>   NEW()
+a   <v1>: {<: Array<Any?>}   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.values b/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.values
index 6168d89842d..b54a25d7dbe 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.values
@@ -7,11 +7,11 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                              <v0>   NEW()          
-2                                                     <v1>   NEW()          
-a                                                     <v2>   NEW()          
-0                                                     <v3>   NEW()
-a > 0                                                 <v4>   NEW(<v2>, <v3>)
-"after"                                               <v5>   NEW()          
-{ "before" do { var a = 2 } while (a > 0) "after" }   <v5>   COPY           
+"before"                                              <v0>: *                      NEW()
+2                                                     <v1>: Int                    NEW()
+a                                                     <v2>: {<: Comparable<Int>}   NEW()
+0                                                     <v3>: Int                    NEW()
+a > 0                                                 <v4>: Boolean                NEW(<v2>, <v3>)
+"after"                                               <v5>: *                      NEW()
+{ "before" do { var a = 2 } while (a > 0) "after" }   <v5>: *                      COPY
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/forScope.values b/compiler/testData/cfg-variables/lexicalScopes/forScope.values
index a48bf428fda..8bcf01b3d9b 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/forScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/forScope.values
@@ -7,11 +7,11 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                              <v0>   NEW()          
-1                                                     <v1>   NEW()          
-10                                                    <v2>   NEW()
-1..10                                                 <v3>   NEW(<v1>, <v2>)
-i                                                     <v5>   NEW()          
-"after"                                               <v6>   NEW()          
-{ "before" for (i in 1..10) { val a = i } "after" }   <v6>   COPY           
+"before"                                              <v0>: *                    NEW()
+1                                                     <v1>: Int                  NEW()
+10                                                    <v2>: Int                  NEW()
+1..10                                                 <v3>: {<: Iterable<Int>}   NEW(<v1>, <v2>)
+i                                                     <v5>: Int                  NEW()
+"after"                                               <v6>: *                    NEW()
+{ "before" for (i in 1..10) { val a = i } "after" }   <v6>: *                    COPY
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.values b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.values
index 5f8baa9bc50..94790e1fd76 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.values
@@ -8,18 +8,18 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                               <v0>   NEW()
-1                                                                      <v1>   NEW()
-{ (x: Int) -> val a = x + b }                                          <v2>   NEW()
-"after"                                                                <v3>   NEW()
-{ "before" val b = 1 val f = { (x: Int) -> val a = x + b } "after" }   <v3>   COPY 
+"before"                                                               <v0>: *                    NEW()
+1                                                                      <v1>: Int                  NEW()
+{ (x: Int) -> val a = x + b }                                          <v2>: {<: (Int) -> Unit}   NEW()
+"after"                                                                <v3>: *                    NEW()
+{ "before" val b = 1 val f = { (x: Int) -> val a = x + b } "after" }   <v3>: *                    COPY
 =====================
 == anonymous_0 ==
 { (x: Int) ->
         val a = x + b
     }
 ---------------------
-x       <v1>   NEW()
-b       <v2>   NEW()
-x + b   <v3>   NEW(<v1>, <v2>)
+x       <v1>: Int   NEW()
+b       <v2>: Int   NEW()
+x + b   <v3>: Int   NEW(<v1>, <v2>)
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/ifScope.values b/compiler/testData/cfg-variables/lexicalScopes/ifScope.values
index 83e8b451ad0..2b5ab5da777 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/ifScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/ifScope.values
@@ -10,10 +10,10 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                          <v0>   NEW()
-true                                                              <v1>   NEW()
-1                                                                 <v2>   NEW()
-2                                                                 <v3>   NEW()
-"after"                                                           <v4>   NEW()
-{ "before" if (true) { val a = 1 } else { val b = 2 } "after" }   <v4>   COPY 
+"before"                                                          <v0>: *         NEW()
+true                                                              <v1>: Boolean   NEW()
+1                                                                 <v2>: Int       NEW()
+2                                                                 <v3>: Int       NEW()
+"after"                                                           <v4>: *         NEW()
+{ "before" if (true) { val a = 1 } else { val b = 2 } "after" }   <v4>: *         COPY
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localClass.values b/compiler/testData/cfg-variables/lexicalScopes/localClass.values
index c9e1ecde4a3..6787b010d9d 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localClass.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/localClass.values
@@ -12,15 +12,15 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                                             <v0>   NEW()
-x                                                                                    <v3>   NEW(<v2>)
-"after"                                                                              <v4>   NEW()
-{ "before" class A(val x: Int) { { val a = x } fun foo() { val b = x } } "after" }   <v4>   COPY
+"before"                                                                             <v0>: *     NEW()
+x                                                                                    <v3>: Int   NEW(<v2>)
+"after"                                                                              <v4>: *     NEW()
+{ "before" class A(val x: Int) { { val a = x } fun foo() { val b = x } } "after" }   <v4>: *     COPY
 =====================
 == foo ==
 fun foo() {
             val b = x
         }
 ---------------------
-x   <v1>   NEW(<v0>)
+x   <v1>: Int   NEW(<v0>)
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.values b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.values
index d995e457ecb..0cd7d1c50ea 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.values
@@ -8,17 +8,17 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                             <v0>   NEW()
-1                                                                    <v1>   NEW()
-"after"                                                              <v2>   NEW()
-{ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" }   <v2>   COPY 
+"before"                                                             <v0>: *     NEW()
+1                                                                    <v1>: Int   NEW()
+"after"                                                              <v2>: *     NEW()
+{ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" }   <v2>: *     COPY
 =====================
 == local ==
 fun local(x: Int) {
         val a = x + b
     }
 ---------------------
-x       <v1>   NEW()
-b       <v2>   NEW()
-x + b   <v3>   NEW(<v1>, <v2>)
+x       <v1>: Int   NEW()
+b       <v2>: Int   NEW()
+x + b   <v3>: Int   NEW(<v1>, <v2>)
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.values b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.values
index 75d4a6fd6dc..b70862c6513 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.values
@@ -6,15 +6,15 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                   <v0>   NEW()
-1                                                          <v1>   NEW()
-"after"                                                    <v2>   NEW()
-{ "before" val b = 1 fun local(x: Int) = x + b "after" }   <v2>   COPY 
+"before"                                                   <v0>: *     NEW()
+1                                                          <v1>: Int   NEW()
+"after"                                                    <v2>: *     NEW()
+{ "before" val b = 1 fun local(x: Int) = x + b "after" }   <v2>: *     COPY
 =====================
 == local ==
 fun local(x: Int) = x + b
 ---------------------
-x       <v1>   NEW()
-b       <v2>   NEW()
-x + b   <v3>   NEW(<v1>, <v2>)
+x       <v1>: Int   NEW()
+b       <v2>: Int   NEW()
+x + b   <v3>: Int   NEW(<v1>, <v2>)
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localObject.values b/compiler/testData/cfg-variables/lexicalScopes/localObject.values
index ac41b36e842..0c9ae1d8ecf 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localObject.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/localObject.values
@@ -12,15 +12,15 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                                  <v0>   NEW()
-1                                                                         <v1>   NEW()
-"after"                                                                   <v2>   NEW()
-{ "before" object A { { val a = 1 } fun foo() { val b = 2 } } "after" }   <v2>   COPY 
+"before"                                                                  <v0>: *     NEW()
+1                                                                         <v1>: Int   NEW()
+"after"                                                                   <v2>: *     NEW()
+{ "before" object A { { val a = 1 } fun foo() { val b = 2 } } "after" }   <v2>: *     COPY
 =====================
 == foo ==
 fun foo() {
             val b = 2
         }
 ---------------------
-2   <v0>   NEW()
+2   <v0>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.values b/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.values
index 73e6fa3cdef..0fc6f4bc18c 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.values
@@ -12,16 +12,16 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                                          <v0>   NEW()
-1                                                                                 <v1>   NEW()
-object { { val x = 1 } fun foo() { val a = 2 } }                                  <v2>   NEW()
-"after"                                                                           <v3>   NEW()
-{ "before" val bar = object { { val x = 1 } fun foo() { val a = 2 } } "after" }   <v3>   COPY 
+"before"                                                                          <v0>: *                    NEW()
+1                                                                                 <v1>: Int                  NEW()
+object { { val x = 1 } fun foo() { val a = 2 } }                                  <v2>: <no name provided>   NEW()
+"after"                                                                           <v3>: *                    NEW()
+{ "before" val bar = object { { val x = 1 } fun foo() { val a = 2 } } "after" }   <v3>: *                    COPY
 =====================
 == foo ==
 fun foo() {
             val a = 2
         }
 ---------------------
-2   <v0>   NEW()
+2   <v0>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values b/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values
index ba1ceaa3737..a38dc2dc87b 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values
@@ -17,12 +17,12 @@ get() {
               return $a
           }
 ---------------------
-$a   <v1>   NEW(<v0>)
+$a   <v1>: Int   NEW(<v0>)
 =====================
 == set_a ==
 set(v: Int) {
               $a = v
           }
 ---------------------
-v   <v2>   NEW()
+v   <v2>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/tryScope.values b/compiler/testData/cfg-variables/lexicalScopes/tryScope.values
index 03919986b84..ce7d64a84c6 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/tryScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/tryScope.values
@@ -13,12 +13,12 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                                                                      <v0>   NEW()
-foo()                                                                                         <v1>   NEW()
-{ foo() }                                                                                     <v1>   COPY
-e                                                                                             <v3>   NEW()
-1                                                                                             <v4>   NEW()
-try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }                        <v1>   COPY 
-"after"                                                                                       <v5>   NEW()
-{ "before" try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 } "after" }   <v5>   COPY 
+"before"                                                                                      <v0>: *                NEW()
+foo()                                                                                         <v1>: *                NEW()
+{ foo() }                                                                                     <v1>: *                COPY
+e                                                                                             <v3>: {<: Exception}   NEW()
+1                                                                                             <v4>: Int              NEW()
+try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }                        <v1>: *                COPY
+"after"                                                                                       <v5>: *                NEW()
+{ "before" try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 } "after" }   <v5>: *                COPY
 =====================
diff --git a/compiler/testData/cfg-variables/lexicalScopes/whileScope.values b/compiler/testData/cfg-variables/lexicalScopes/whileScope.values
index 01858675810..a8c0d80a31a 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/whileScope.values
+++ b/compiler/testData/cfg-variables/lexicalScopes/whileScope.values
@@ -7,8 +7,8 @@ fun foo() {
     "after"
 }
 ---------------------
-"before"                                           <v0>   NEW()
-true                                               <v1>   NEW()
-"after"                                            <v2>   NEW()
-{ "before" while (true) { val a: Int } "after" }   <v2>   COPY 
+"before"                                           <v0>: *   NEW()
+true                                               <v1>: *   NEW()
+"after"                                            <v2>: *   NEW()
+{ "before" while (true) { val a: Int } "after" }   <v2>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/ArrayAccess.values b/compiler/testData/cfg/arrays/ArrayAccess.values
index bc136e3fe81..c6a7315e367 100644
--- a/compiler/testData/cfg/arrays/ArrayAccess.values
+++ b/compiler/testData/cfg/arrays/ArrayAccess.values
@@ -9,21 +9,21 @@ fun foo() {
   a[10] += 1
 }
 ---------------------
-Array<Int>                                                  <v0>    NEW()
-3                                                           <v1>    NEW()                   
-a                                                           <v2>    NEW()                   
-10                                                          <v3>    NEW()                   
-4                                                           <v4>    NEW()                   
-a[10] = 4                                                   <v5>    NEW(<v2>, <v3>, <v4>)   
-2                                                           <v6>    NEW()                   
-a                                                           <v7>    NEW()                   
-10                                                          <v8>    NEW()                   
-a[10]                                                       <v9>    NEW(<v7>, <v8>)         
-100                                                         <v10>   NEW()                   
-a                                                           <v16>   NEW()                   
-10                                                          <v17>   NEW()                   
-a[10]                                                       <v13>   NEW(<v11>, <v12>)       
-1                                                           <v14>   NEW()
-a[10] += 1                                                  <v18>   NEW(<v16>, <v17>, <v15>)
-{ val a = Array<Int> 3 a[10] = 4 2 a[10] 100 a[10] += 1 }   <v18>   COPY                    
+Array<Int>                                                  <v0>: {<: Array<Int>}    NEW()
+3                                                           <v1>: *                  NEW()
+a                                                           <v2>: {<: Array<Int>}    NEW()
+10                                                          <v3>: Int                NEW()
+4                                                           <v4>: Int                NEW()
+a[10] = 4                                                   <v5>: *                  NEW(<v2>, <v3>, <v4>)
+2                                                           <v6>: *                  NEW()
+a                                                           <v7>: {<: Array<Int>}    NEW()
+10                                                          <v8>: Int                NEW()
+a[10]                                                       <v9>: *                  NEW(<v7>, <v8>)
+100                                                         <v10>: *                 NEW()
+a                                                           <v16>: {<: Array<Int>}   NEW()
+10                                                          <v17>: Int               NEW()
+a[10]                                                       <v13>: Int               NEW(<v11>, <v12>)
+1                                                           <v14>: Int               NEW()
+a[10] += 1                                                  <v18>: *                 NEW(<v16>, <v17>, <v15>)
+{ val a = Array<Int> 3 a[10] = 4 2 a[10] 100 a[10] += 1 }   <v18>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/ArrayOfFunctions.values b/compiler/testData/cfg/arrays/ArrayOfFunctions.values
index 789e1185393..2fd1a0238ac 100644
--- a/compiler/testData/cfg/arrays/ArrayOfFunctions.values
+++ b/compiler/testData/cfg/arrays/ArrayOfFunctions.values
@@ -3,10 +3,10 @@ fun test(array: Array<(Int)->Unit>) {
     array[11](3)
 }
 ---------------------
-array              <v1>   NEW()
-11                 <v2>   NEW()
-array[11]          <v3>   NEW(<v1>, <v2>)
-3                  <v4>   NEW()
-array[11](3)       <v5>   NEW(<v3>, <v4>)
-{ array[11](3) }   <v5>   COPY
+array              <v1>: {<: Array<(Int) -> Unit>}   NEW()
+11                 <v2>: Int                         NEW()
+array[11]          <v3>: {<: (Int) -> Unit}          NEW(<v1>, <v2>)
+3                  <v4>: Int                         NEW()
+array[11](3)       <v5>: *                           NEW(<v3>, <v4>)
+{ array[11](3) }   <v5>: *                           COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/arrayAccessExpression.values b/compiler/testData/cfg/arrays/arrayAccessExpression.values
index fee89dd84b8..0328f66872c 100644
--- a/compiler/testData/cfg/arrays/arrayAccessExpression.values
+++ b/compiler/testData/cfg/arrays/arrayAccessExpression.values
@@ -13,10 +13,10 @@ fun test(ab: Ab) {
     ab.getArray()[1]
 }
 ---------------------
-ab                     <v1>   NEW()
-getArray()             <v2>   NEW(<v1>)
-ab.getArray()          <v2>   COPY
-1                      <v3>   NEW()          
-ab.getArray()[1]       <v4>   NEW(<v2>, <v3>)
-{ ab.getArray()[1] }   <v4>   COPY           
+ab                     <v1>: {<: Ab}           NEW()
+getArray()             <v2>: {<: Array<Int>}   NEW(<v1>)
+ab.getArray()          <v2>: {<: Array<Int>}   COPY
+1                      <v3>: Int               NEW()
+ab.getArray()[1]       <v4>: *                 NEW(<v2>, <v3>)
+{ ab.getArray()[1] }   <v4>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/arrayInc.values b/compiler/testData/cfg/arrays/arrayInc.values
index 0b078b11564..c2a550bd58b 100644
--- a/compiler/testData/cfg/arrays/arrayInc.values
+++ b/compiler/testData/cfg/arrays/arrayInc.values
@@ -3,9 +3,9 @@ fun foo(a: Array<Int>) {
     a[0]++
 }
 ---------------------
-a            <v5>   NEW()
-0            <v6>   NEW()
-a[0]         <v3>   NEW(<v1>, <v2>)
-a[0]++       <v3>   COPY
-{ a[0]++ }   <v3>   COPY
+a            <v5>: {<: Array<Int>}   NEW()
+0            <v6>: Int               NEW()
+a[0]         <v3>: Int               NEW(<v1>, <v2>)
+a[0]++       <v3>: Int               COPY
+{ a[0]++ }   <v3>: Int               COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/arraySet.values b/compiler/testData/cfg/arrays/arraySet.values
index bfed5c9d479..15ca1d7a79f 100644
--- a/compiler/testData/cfg/arrays/arraySet.values
+++ b/compiler/testData/cfg/arrays/arraySet.values
@@ -3,9 +3,9 @@ fun foo(a: Array<Int>) {
     a[1] = 2
 }
 ---------------------
-a              <v1>   NEW()
-1              <v2>   NEW()
-2              <v3>   NEW()
-a[1] = 2       <v4>   NEW(<v1>, <v2>, <v3>)
-{ a[1] = 2 }   <v4>   COPY
+a              <v1>: {<: Array<Int>}   NEW()
+1              <v2>: Int               NEW()
+2              <v3>: Int               NEW()
+a[1] = 2       <v4>: *                 NEW(<v1>, <v2>, <v3>)
+{ a[1] = 2 }   <v4>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/arrays/arraySetPlusAssign.values b/compiler/testData/cfg/arrays/arraySetPlusAssign.values
index bd6d86ed9b6..e25b40da814 100644
--- a/compiler/testData/cfg/arrays/arraySetPlusAssign.values
+++ b/compiler/testData/cfg/arrays/arraySetPlusAssign.values
@@ -3,10 +3,10 @@ fun foo(a: Array<Int>) {
     a[0] += 1
 }
 ---------------------
-a               <v6>   NEW()
-0               <v7>   NEW()                
-a[0]            <v3>   NEW(<v1>, <v2>)      
-1               <v4>   NEW()
-a[0] += 1       <v8>   NEW(<v6>, <v7>, <v5>)
-{ a[0] += 1 }   <v8>   COPY                 
+a               <v6>: {<: Array<Int>}   NEW()
+0               <v7>: Int               NEW()
+a[0]            <v3>: Int               NEW(<v1>, <v2>)
+1               <v4>: Int               NEW()
+a[0] += 1       <v8>: *                 NEW(<v6>, <v7>, <v5>)
+{ a[0] += 1 }   <v8>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/basic/Basic.values b/compiler/testData/cfg/basic/Basic.values
index 979de60120b..2b597aef89a 100644
--- a/compiler/testData/cfg/basic/Basic.values
+++ b/compiler/testData/cfg/basic/Basic.values
@@ -17,40 +17,40 @@ fun f(a : Boolean) : Unit {
 
 }
 ---------------------
-1                                                                                                        <v1>    NEW()
-a                                                                                                        <v2>    NEW()            
-2                                                                                                        <v3>    NEW()            
-toLong()                                                                                                 <v4>    NEW(<v3>)
-2.toLong()                                                                                               <v4>    COPY
-a                                                                                                        <v5>    NEW()
-3                                                                                                        <v6>    NEW()            
-foo(a, 3)                                                                                                <v7>    NEW(<v5>, <v6>)
-genfun<Any>()                                                                                            <v8>    NEW()
-{1}                                                                                                      <v9>    NEW()            
-flfun {1}                                                                                                <v10>   NEW(<v9>)
-3                                                                                                        <v11>   NEW()            
-4                                                                                                        <v12>   NEW()
-equals(4)                                                                                                <v13>   NEW(<v11>, <v12>)
-3.equals(4)                                                                                              <v13>   COPY             
-3                                                                                                        <v14>   NEW()            
-4                                                                                                        <v15>   NEW()
-3 equals 4                                                                                               <v16>   NEW(<v14>, <v15>)
-1                                                                                                        <v17>   NEW()            
-2                                                                                                        <v18>   NEW()
-1 + 2                                                                                                    <v19>   NEW(<v17>, <v18>)
-a                                                                                                        <v20>   NEW()            
-true                                                                                                     <v21>   NEW()            
-a && true                                                                                                <v22>   NEW(<v20>, <v21>)
-a                                                                                                        <v23>   NEW()            
-false                                                                                                    <v24>   NEW()            
-a || false                                                                                               <v25>   NEW(<v23>, <v24>)
-{ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false }   <v25>   COPY             
+1                                                                                                        <v1>: *                         NEW()
+a                                                                                                        <v2>: *                         NEW()
+2                                                                                                        <v3>: {<: Number}               NEW()
+toLong()                                                                                                 <v4>: *                         NEW(<v3>)
+2.toLong()                                                                                               <v4>: *                         COPY
+a                                                                                                        <v5>: Boolean                   NEW()
+3                                                                                                        <v6>: Int                       NEW()
+foo(a, 3)                                                                                                <v7>: *                         NEW(<v5>, <v6>)
+genfun<Any>()                                                                                            <v8>: *                         NEW()
+{1}                                                                                                      <v9>: {<: () -> Any}            NEW()
+flfun {1}                                                                                                <v10>: *                        NEW(<v9>)
+3                                                                                                        <v11>: OR{{<: Any}, {<: Any}}   NEW()
+4                                                                                                        <v12>: {<: Any?}                NEW()
+equals(4)                                                                                                <v13>: *                        NEW(<v11>, <v12>)
+3.equals(4)                                                                                              <v13>: *                        COPY
+3                                                                                                        <v14>: OR{{<: Any}, {<: Any}}   NEW()
+4                                                                                                        <v15>: {<: Any?}                NEW()
+3 equals 4                                                                                               <v16>: *                        NEW(<v14>, <v15>)
+1                                                                                                        <v17>: Int                      NEW()
+2                                                                                                        <v18>: Int                      NEW()
+1 + 2                                                                                                    <v19>: *                        NEW(<v17>, <v18>)
+a                                                                                                        <v20>: Boolean                  NEW()
+true                                                                                                     <v21>: Boolean                  NEW()
+a && true                                                                                                <v22>: *                        NEW(<v20>, <v21>)
+a                                                                                                        <v23>: Boolean                  NEW()
+false                                                                                                    <v24>: Boolean                  NEW()
+a || false                                                                                               <v25>: *                        NEW(<v23>, <v24>)
+{ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false }   <v25>: *                        COPY
 =====================
 == anonymous_0 ==
 {1}
 ---------------------
-1   <v0>   NEW()
-1   <v0>   COPY 
+1   <v0>: Int   NEW()
+1   <v0>: Int   COPY
 =====================
 == foo ==
 fun foo(a : Boolean, b : Int) : Unit {}
diff --git a/compiler/testData/cfg/basic/ShortFunction.values b/compiler/testData/cfg/basic/ShortFunction.values
index c30b60d47d4..f2c7d17510e 100644
--- a/compiler/testData/cfg/basic/ShortFunction.values
+++ b/compiler/testData/cfg/basic/ShortFunction.values
@@ -1,5 +1,5 @@
 == short ==
 fun short() = 1
 ---------------------
-1   <v0>   NEW()
+1   <v0>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/bugs/jumpToOuterScope.values b/compiler/testData/cfg/bugs/jumpToOuterScope.values
index 3f158c01d81..f58075297ea 100644
--- a/compiler/testData/cfg/bugs/jumpToOuterScope.values
+++ b/compiler/testData/cfg/bugs/jumpToOuterScope.values
@@ -7,9 +7,9 @@ fun foo(c: Collection<Int>) {
     }
 }
 ---------------------
-c               <v1>   NEW()
-{ break }       <v3>   NEW()
-{ { break } }   <v3>   COPY
+c               <v1>: {<: Iterable<Int>}   NEW()
+{ break }       <v3>: *                    NEW()
+{ { break } }   <v3>: *                    COPY
 =====================
 == anonymous_0 ==
 {
diff --git a/compiler/testData/cfg/controlStructures/Finally.values b/compiler/testData/cfg/controlStructures/Finally.values
index d6ffe48bae5..8765ede1b36 100644
--- a/compiler/testData/cfg/controlStructures/Finally.values
+++ b/compiler/testData/cfg/controlStructures/Finally.values
@@ -7,12 +7,12 @@ fun t1() {
   }
 }
 ---------------------
-1                             <v0>   NEW()
-{ 1 }                         <v0>   COPY 
-2                             <v1>   NEW()
-{ 2 }                         <v1>   COPY 
-try { 1 } finally { 2 }       <v0>   COPY 
-{ try { 1 } finally { 2 } }   <v0>   COPY 
+1                             <v0>: *   NEW()
+{ 1 }                         <v0>: *   COPY 
+2                             <v1>: *   NEW()
+{ 2 }                         <v1>: *   COPY 
+try { 1 } finally { 2 }       <v0>: *   COPY 
+{ try { 1 } finally { 2 } }   <v0>: *   COPY 
 =====================
 == t2 ==
 fun t2() {
@@ -26,12 +26,12 @@ fun t2() {
   }
 }
 ---------------------
-1       <v0>   NEW()          
-2       <v1>   NEW()          
-3       <v2>   NEW()
-2 > 3   <v3>   NEW(<v1>, <v2>)
-2       <v4>   NEW()          
-{ 2 }   <v4>   COPY           
+1       <v0>: *                      NEW()          
+2       <v1>: {<: Comparable<Int>}   NEW()          
+3       <v2>: Int                    NEW()          
+2 > 3   <v3>: Boolean                NEW(<v1>, <v2>)
+2       <v4>: *                      NEW()          
+{ 2 }   <v4>: *                      COPY           
 =====================
 == t3 ==
 fun t3() {
@@ -47,14 +47,14 @@ fun t3() {
   }
 }
 ---------------------
-1                                                                 <v0>   NEW()
-{ () -> if (2 > 3) { return@l } }                                 <v1>   NEW()
-@l{ () -> if (2 > 3) { return@l } }                               <v1>   COPY 
-{ 1 @l{ () -> if (2 > 3) { return@l } } }                         <v1>   COPY 
-2                                                                 <v2>   NEW()
-{ 2 }                                                             <v2>   COPY 
-try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }       <v1>   COPY 
-{ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } }   <v1>   COPY 
+1                                                                 <v0>: *   NEW()
+{ () -> if (2 > 3) { return@l } }                                 <v1>: *   NEW()
+@l{ () -> if (2 > 3) { return@l } }                               <v1>: *   COPY 
+{ 1 @l{ () -> if (2 > 3) { return@l } } }                         <v1>: *   COPY 
+2                                                                 <v2>: *   NEW()
+{ 2 }                                                             <v2>: *   COPY 
+try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }       <v1>: *   COPY 
+{ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } }   <v1>: *   COPY 
 =====================
 == anonymous_0 ==
 { () ->
@@ -63,9 +63,9 @@ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }       <v1>   COPY
         }
     }
 ---------------------
-2       <v0>   NEW()          
-3       <v1>   NEW()
-2 > 3   <v2>   NEW(<v0>, <v1>)
+2       <v0>: {<: Comparable<Int>}   NEW()          
+3       <v1>: Int                    NEW()          
+2 > 3   <v2>: Boolean                NEW(<v0>, <v1>)
 =====================
 == t4 ==
 fun t4() {
@@ -81,9 +81,9 @@ fun t4() {
   }
 }
 ---------------------
-{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }         <v0>   NEW()
-@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }       <v0>   COPY 
-{ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }   <v0>   COPY 
+{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }         <v0>: *   NEW()
+@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }       <v0>: *   COPY 
+{ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }   <v0>: *   COPY 
 =====================
 == anonymous_1 ==
 { () ->
@@ -97,12 +97,12 @@ fun t4() {
     }
   }
 ---------------------
-1       <v0>   NEW()          
-2       <v1>   NEW()          
-3       <v2>   NEW()
-2 > 3   <v3>   NEW(<v1>, <v2>)
-2       <v4>   NEW()          
-{ 2 }   <v4>   COPY           
+1       <v0>: *                      NEW()          
+2       <v1>: {<: Comparable<Int>}   NEW()          
+3       <v2>: Int                    NEW()          
+2 > 3   <v3>: Boolean                NEW(<v1>, <v2>)
+2       <v4>: *                      NEW()          
+{ 2 }   <v4>: *                      COPY           
 =====================
 == t5 ==
 fun t5() {
@@ -118,13 +118,13 @@ fun t5() {
   }
 }
 ---------------------
-true    <v0>   NEW()          
-1       <v1>   NEW()          
-2       <v2>   NEW()          
-3       <v3>   NEW()
-2 > 3   <v4>   NEW(<v2>, <v3>)
-2       <v5>   NEW()          
-{ 2 }   <v5>   COPY           
+true    <v0>: *                      NEW()          
+1       <v1>: *                      NEW()          
+2       <v2>: {<: Comparable<Int>}   NEW()          
+3       <v3>: Int                    NEW()          
+2 > 3   <v4>: Boolean                NEW(<v2>, <v3>)
+2       <v5>: *                      NEW()          
+{ 2 }   <v5>: *                      COPY           
 =====================
 == t6 ==
 fun t6() {
@@ -141,17 +141,17 @@ fun t6() {
   }
 }
 ---------------------
-true                                                                       <v0>   NEW()          
-1                                                                          <v1>   NEW()          
-2                                                                          <v2>   NEW()          
-3                                                                          <v3>   NEW()
-2 > 3                                                                      <v4>   NEW(<v2>, <v3>)
-5                                                                          <v5>   NEW()          
-{ @l while(true) { 1 if (2 > 3) { break @l } } 5 }                         <v5>   COPY           
-2                                                                          <v6>   NEW()          
-{ 2 }                                                                      <v6>   COPY           
-try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }       <v5>   COPY           
-{ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } }   <v5>   COPY           
+true                                                                       <v0>: *                      NEW()          
+1                                                                          <v1>: *                      NEW()          
+2                                                                          <v2>: {<: Comparable<Int>}   NEW()          
+3                                                                          <v3>: Int                    NEW()          
+2 > 3                                                                      <v4>: Boolean                NEW(<v2>, <v3>)
+5                                                                          <v5>: *                      NEW()          
+{ @l while(true) { 1 if (2 > 3) { break @l } } 5 }                         <v5>: *                      COPY           
+2                                                                          <v6>: *                      NEW()          
+{ 2 }                                                                      <v6>: *                      COPY           
+try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }       <v5>: *                      COPY           
+{ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } }   <v5>: *                      COPY           
 =====================
 == t7 ==
 fun t7() {
@@ -167,13 +167,13 @@ fun t7() {
   }
 }
 ---------------------
-true    <v0>   NEW()          
-1       <v1>   NEW()          
-2       <v2>   NEW()          
-3       <v3>   NEW()
-2 > 3   <v4>   NEW(<v2>, <v3>)
-2       <v5>   NEW()          
-{ 2 }   <v5>   COPY           
+true    <v0>: *                      NEW()          
+1       <v1>: *                      NEW()          
+2       <v2>: {<: Comparable<Int>}   NEW()          
+3       <v3>: Int                    NEW()          
+2 > 3   <v4>: Boolean                NEW(<v2>, <v3>)
+2       <v5>: *                      NEW()          
+{ 2 }   <v5>: *                      COPY           
 =====================
 == t8 ==
 fun t8(a : Int) {
@@ -189,15 +189,15 @@ fun t8(a : Int) {
   }
 }
 ---------------------
-1       <v1>   NEW()
-a       <v2>   NEW()
-1..a    <v3>   NEW(<v1>, <v2>)
-1       <v5>   NEW()
-2       <v6>   NEW()
-3       <v7>   NEW()
-2 > 3   <v8>   NEW(<v6>, <v7>)
-2       <v9>   NEW()
-{ 2 }   <v9>   COPY
+1       <v1>: Int                    NEW()          
+a       <v2>: Int                    NEW()          
+1..a    <v3>: {<: Iterable<Int>}     NEW(<v1>, <v2>)
+1       <v5>: *                      NEW()          
+2       <v6>: {<: Comparable<Int>}   NEW()          
+3       <v7>: Int                    NEW()          
+2 > 3   <v8>: Boolean                NEW(<v6>, <v7>)
+2       <v9>: *                      NEW()          
+{ 2 }   <v9>: *                      COPY           
 =====================
 == t9 ==
 fun t9(a : Int) {
@@ -214,19 +214,19 @@ fun t9(a : Int) {
   }
 }
 ---------------------
-1                                                                                 <v1>    NEW()
-a                                                                                 <v2>    NEW()
-1..a                                                                              <v3>    NEW(<v1>, <v2>)
-1                                                                                 <v5>    NEW()          
-2                                                                                 <v6>    NEW()          
-3                                                                                 <v7>    NEW()
-2 > 3                                                                             <v8>    NEW(<v6>, <v7>)
-5                                                                                 <v9>    NEW()          
-{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 }                         <v9>    COPY           
-2                                                                                 <v10>   NEW()          
-{ 2 }                                                                             <v10>   COPY           
-try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }       <v9>    COPY           
-{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } }   <v9>    COPY           
+1                                                                                 <v1>: Int                    NEW()          
+a                                                                                 <v2>: Int                    NEW()          
+1..a                                                                              <v3>: {<: Iterable<Int>}     NEW(<v1>, <v2>)
+1                                                                                 <v5>: *                      NEW()          
+2                                                                                 <v6>: {<: Comparable<Int>}   NEW()          
+3                                                                                 <v7>: Int                    NEW()          
+2 > 3                                                                             <v8>: Boolean                NEW(<v6>, <v7>)
+5                                                                                 <v9>: *                      NEW()          
+{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 }                         <v9>: *                      COPY           
+2                                                                                 <v10>: *                     NEW()          
+{ 2 }                                                                             <v10>: *                     COPY           
+try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }       <v9>: *                      COPY           
+{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } }   <v9>: *                      COPY           
 =====================
 == t10 ==
 fun t10(a : Int) {
@@ -242,15 +242,15 @@ fun t10(a : Int) {
   }
 }
 ---------------------
-1       <v1>   NEW()
-a       <v2>   NEW()
-1..a    <v3>   NEW(<v1>, <v2>)
-1       <v5>   NEW()
-2       <v6>   NEW()
-3       <v7>   NEW()
-2 > 3   <v8>   NEW(<v6>, <v7>)
-2       <v9>   NEW()
-{ 2 }   <v9>   COPY
+1       <v1>: Int                    NEW()          
+a       <v2>: Int                    NEW()          
+1..a    <v3>: {<: Iterable<Int>}     NEW(<v1>, <v2>)
+1       <v5>: *                      NEW()          
+2       <v6>: {<: Comparable<Int>}   NEW()          
+3       <v7>: Int                    NEW()          
+2 > 3   <v8>: Boolean                NEW(<v6>, <v7>)
+2       <v9>: *                      NEW()          
+{ 2 }   <v9>: *                      COPY           
 =====================
 == t11 ==
 fun t11() {
@@ -262,8 +262,8 @@ fun t11() {
   }
 }
 ---------------------
-1   <v0>   NEW()
-2   <v1>   NEW()
+1   <v0>: *      NEW()
+2   <v1>: Unit   NEW()
 =====================
 == t12 ==
 fun t12() : Int {
@@ -275,10 +275,10 @@ fun t12() : Int {
     }
 }
 ---------------------
-1               <v0>   NEW()    
-3               <v1>   NEW()
-doSmth(3)       <v2>   NEW(<v1>)
-{ doSmth(3) }   <v2>   COPY     
+1               <v0>: Int   NEW()    
+3               <v1>: Int   NEW()    
+doSmth(3)       <v2>: *     NEW(<v1>)
+{ doSmth(3) }   <v2>: *     COPY     
 =====================
 == t13 ==
 fun t13() : Int {
@@ -293,15 +293,15 @@ fun t13() : Int {
     }
 }
 ---------------------
-1                                                                                                   <v0>   NEW()    
-2                                                                                                   <v4>   NEW()
-doSmth(2)                                                                                           <v5>   NEW(<v4>)
-{ doSmth(2) }                                                                                       <v5>   COPY     
-3                                                                                                   <v1>   NEW()
-doSmth(3)                                                                                           <v2>   NEW(<v1>)
-{ doSmth(3) }                                                                                       <v2>   COPY     
-try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }       <v5>   COPY     
-{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }   <v5>   COPY     
+1                                                                                                   <v0>: Int   NEW()    
+2                                                                                                   <v4>: Int   NEW()    
+doSmth(2)                                                                                           <v5>: *     NEW(<v4>)
+{ doSmth(2) }                                                                                       <v5>: *     COPY     
+3                                                                                                   <v1>: Int   NEW()    
+doSmth(3)                                                                                           <v2>: *     NEW(<v1>)
+{ doSmth(3) }                                                                                       <v2>: *     COPY     
+try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }       <v5>: *     COPY     
+{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }   <v5>: *     COPY     
 =====================
 == t14 ==
 fun t14() : Int {
@@ -313,12 +313,12 @@ fun t14() : Int {
     }
 }
 ---------------------
-1                                                                             <v0>   NEW()    
-2                                                                             <v2>   NEW()
-doSmth(2)                                                                     <v3>   NEW(<v2>)
-{ doSmth(2) }                                                                 <v3>   COPY     
-try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }       <v3>   COPY     
-{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }   <v3>   COPY     
+1                                                                             <v0>: Int   NEW()    
+2                                                                             <v2>: Int   NEW()    
+doSmth(2)                                                                     <v3>: *     NEW(<v2>)
+{ doSmth(2) }                                                                 <v3>: *     COPY     
+try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }       <v3>: *     COPY     
+{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }   <v3>: *     COPY     
 =====================
 == t15 ==
 fun t15() : Int {
@@ -333,11 +333,11 @@ fun t15() : Int {
     }
 }
 ---------------------
-1               <v0>   NEW()
-2               <v4>   NEW()
-3               <v1>   NEW()
-doSmth(3)       <v2>   NEW(<v1>)
-{ doSmth(3) }   <v2>   COPY
+1               <v0>: Int   NEW()    
+2               <v4>: Int   NEW()    
+3               <v1>: Int   NEW()    
+doSmth(3)       <v2>: *     NEW(<v1>)
+{ doSmth(3) }   <v2>: *     COPY     
 =====================
 == t16 ==
 fun t16() : Int {
@@ -352,15 +352,15 @@ fun t16() : Int {
     }
 }
 ---------------------
-1                                                                                                   <v0>   NEW()
-doSmth(1)                                                                                           <v1>   NEW(<v0>)
-{ doSmth(1) }                                                                                       <v1>   COPY     
-2                                                                                                   <v3>   NEW()
-3                                                                                                   <v4>   NEW()
-doSmth(3)                                                                                           <v5>   NEW(<v4>)
-{ doSmth(3) }                                                                                       <v5>   COPY     
-try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }       <v1>   COPY     
-{ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }   <v1>   COPY     
+1                                                                                                   <v0>: Int   NEW()    
+doSmth(1)                                                                                           <v1>: *     NEW(<v0>)
+{ doSmth(1) }                                                                                       <v1>: *     COPY     
+2                                                                                                   <v3>: Int   NEW()    
+3                                                                                                   <v4>: Int   NEW()    
+doSmth(3)                                                                                           <v5>: *     NEW(<v4>)
+{ doSmth(3) }                                                                                       <v5>: *     COPY     
+try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }       <v1>: *     COPY     
+{ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }   <v1>: *     COPY     
 =====================
 == doSmth ==
 fun doSmth(i: Int) {
diff --git a/compiler/testData/cfg/controlStructures/FinallyTestCopy.values b/compiler/testData/cfg/controlStructures/FinallyTestCopy.values
index 9a622cdbac2..e49fa806b52 100644
--- a/compiler/testData/cfg/controlStructures/FinallyTestCopy.values
+++ b/compiler/testData/cfg/controlStructures/FinallyTestCopy.values
@@ -30,15 +30,15 @@ fun testCopy1() : Int {
     }
 }
 ---------------------
-doSmth()                                                                                                                     <v0>   NEW()
-{ doSmth() }                                                                                                                 <v0>   COPY
-doSmth1()                                                                                                                    <v2>   NEW()
-{ doSmth1() }                                                                                                                <v2>   COPY
-doSmth2()                                                                                                                    <v4>   NEW()
-{ doSmth2() }                                                                                                                <v4>   COPY
-1                                                                                                                            <v5>   NEW()                
-try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }       <v6>   NEW(<v0>, <v2>, <v4>)
-{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } }   <v6>   COPY                 
+doSmth()                                                                                                                     <v0>: *     NEW()
+{ doSmth() }                                                                                                                 <v0>: *     COPY
+doSmth1()                                                                                                                    <v2>: *     NEW()
+{ doSmth1() }                                                                                                                <v2>: *     COPY
+doSmth2()                                                                                                                    <v4>: *     NEW()
+{ doSmth2() }                                                                                                                <v4>: *     COPY
+1                                                                                                                            <v5>: Int   NEW()
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }       <v6>: *     NEW(<v0>, <v2>, <v4>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } }   <v6>: *     COPY
 =====================
 == testCopy2 ==
 fun testCopy2() {
@@ -59,16 +59,16 @@ fun testCopy2() {
     }
 }
 ---------------------
-cond()                                                                                                                                               <v0>   NEW()
-doSmth()                                                                                                                                             <v1>   NEW()
-{ doSmth() }                                                                                                                                         <v1>   COPY
-doSmth1()                                                                                                                                            <v3>   NEW()
-{ doSmth1() }                                                                                                                                        <v3>   COPY
-doSmth2()                                                                                                                                            <v5>   NEW()
-{ doSmth2() }                                                                                                                                        <v5>   COPY
-cond()                                                                                                                                               <v6>   NEW()
-try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }       <v7>   NEW(<v1>, <v3>, <v5>)
-{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }   <v7>   COPY                 
+cond()                                                                                                                                               <v0>: Boolean   NEW()
+doSmth()                                                                                                                                             <v1>: *         NEW()
+{ doSmth() }                                                                                                                                         <v1>: *         COPY
+doSmth1()                                                                                                                                            <v3>: *         NEW()
+{ doSmth1() }                                                                                                                                        <v3>: *         COPY
+doSmth2()                                                                                                                                            <v5>: *         NEW()
+{ doSmth2() }                                                                                                                                        <v5>: *         COPY
+cond()                                                                                                                                               <v6>: Boolean   NEW()
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }       <v7>: *         NEW(<v1>, <v3>, <v5>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }   <v7>: *         COPY
 =====================
 == testCopy3 ==
 fun testCopy3() {
@@ -86,15 +86,15 @@ fun testCopy3() {
     }
 }
 ---------------------
-doSmth()                                                                                                                            <v0>   NEW()
-{ doSmth() }                                                                                                                        <v0>   COPY
-doSmth1()                                                                                                                           <v2>   NEW()
-{ doSmth1() }                                                                                                                       <v2>   COPY
-doSmth2()                                                                                                                           <v4>   NEW()
-{ doSmth2() }                                                                                                                       <v4>   COPY
-cond()                                                                                                                              <v5>   NEW()
-try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }       <v6>   NEW(<v0>, <v2>, <v4>)
-{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } }   <v6>   COPY                 
+doSmth()                                                                                                                            <v0>: *         NEW()
+{ doSmth() }                                                                                                                        <v0>: *         COPY
+doSmth1()                                                                                                                           <v2>: *         NEW()
+{ doSmth1() }                                                                                                                       <v2>: *         COPY
+doSmth2()                                                                                                                           <v4>: *         NEW()
+{ doSmth2() }                                                                                                                       <v4>: *         COPY
+cond()                                                                                                                              <v5>: Boolean   NEW()
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }       <v6>: *         NEW(<v0>, <v2>, <v4>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } }   <v6>: *         COPY
 =====================
 == doTestCopy4 ==
 fun doTestCopy4(list: List<String>?) : Int {
@@ -107,11 +107,11 @@ fun doTestCopy4(list: List<String>?) : Int {
     }
 }
 ---------------------
-doSmth()                                                <v1>   NEW()
-{ doSmth() }                                            <v1>   COPY
-list                                                    <v2>   NEW()          
-null                                                    <v3>   NEW()
-list != null                                            <v4>   NEW(<v2>, <v3>)
-try { doSmth() } finally { if(list != null) { } }       <v1>   COPY           
-{ try { doSmth() } finally { if(list != null) { } } }   <v1>   COPY           
+doSmth()                                                <v1>: *           NEW()
+{ doSmth() }                                            <v1>: *           COPY
+list                                                    <v2>: {<: Any?}   NEW()
+null                                                    <v3>: {<: Any?}   NEW()
+list != null                                            <v4>: Boolean     NEW(<v2>, <v3>)
+try { doSmth() } finally { if(list != null) { } }       <v1>: *           COPY
+{ try { doSmth() } finally { if(list != null) { } } }   <v1>: *           COPY
 =====================
diff --git a/compiler/testData/cfg/controlStructures/For.values b/compiler/testData/cfg/controlStructures/For.values
index c7b2ce12294..027b5496c73 100644
--- a/compiler/testData/cfg/controlStructures/For.values
+++ b/compiler/testData/cfg/controlStructures/For.values
@@ -5,12 +5,12 @@ fun t1() {
     }
 }
 ---------------------
-1               <v0>   NEW()          
-2               <v1>   NEW()
-1..2            <v2>   NEW(<v0>, <v1>)
-i               <v4>   NEW()          
-doSmth(i)       <v5>   NEW(<v4>)
-{ doSmth(i) }   <v5>   COPY           
+1               <v0>: Int                  NEW()
+2               <v1>: Int                  NEW()
+1..2            <v2>: {<: Iterable<Int>}   NEW(<v0>, <v1>)
+i               <v4>: Int                  NEW()
+doSmth(i)       <v5>: *                    NEW(<v4>)
+{ doSmth(i) }   <v5>: *                    COPY
 =====================
 == doSmth ==
 fun doSmth(i: Int) {}
diff --git a/compiler/testData/cfg/controlStructures/If.values b/compiler/testData/cfg/controlStructures/If.values
index f0055a9467d..e2c4f2cf276 100644
--- a/compiler/testData/cfg/controlStructures/If.values
+++ b/compiler/testData/cfg/controlStructures/If.values
@@ -16,16 +16,16 @@ fun t1(b: Boolean) {
     doSmth(r)
 }
 ---------------------
-b                                                                                                            <v1>   NEW()
-"s"                                                                                                          <v2>   NEW()    
-u                                                                                                            <v3>   NEW()
-doSmth(u)                                                                                                    <v4>   NEW(<v3>)
-b                                                                                                            <v5>   NEW()    
-"s"                                                                                                          <v6>   NEW()    
-"t"                                                                                                          <v7>   NEW()    
-r                                                                                                            <v8>   NEW()
-doSmth(r)                                                                                                    <v9>   NEW(<v8>)
-{ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) }   <v9>   COPY     
+b                                                                                                            <v1>: Boolean   NEW()
+"s"                                                                                                          <v2>: String    NEW()
+u                                                                                                            <v3>: String    NEW()
+doSmth(u)                                                                                                    <v4>: *         NEW(<v3>)
+b                                                                                                            <v5>: Boolean   NEW()
+"s"                                                                                                          <v6>: String    NEW()
+"t"                                                                                                          <v7>: String    NEW()
+r                                                                                                            <v8>: String    NEW()
+doSmth(r)                                                                                                    <v9>: *         NEW(<v8>)
+{ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) }   <v9>: *         COPY
 =====================
 == t2 ==
 fun t2(b: Boolean) {
@@ -39,12 +39,12 @@ fun t2(b: Boolean) {
     }
 }
 ---------------------
-3           <v1>   NEW()
-b           <v2>   NEW()
-i           <v3>   NEW()
-doSmth(i)   <v4>   NEW(<v3>)
-i           <v5>   NEW()
-i is Int    <v6>   NEW(<v5>)
+3           <v1>: Int       NEW()
+b           <v2>: Boolean   NEW()
+i           <v3>: String    NEW()
+doSmth(i)   <v4>: *         NEW(<v3>)
+i           <v5>: *         NEW()
+i is Int    <v6>: Boolean   NEW(<v5>)
 =====================
 == doSmth ==
 fun doSmth(s: String) {}
diff --git a/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.values b/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.values
index b01dad9a5e4..b6eaafa0d7c 100644
--- a/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.values
+++ b/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.values
@@ -5,11 +5,11 @@ fun main() {
     }
 }
 ---------------------
-0       <v0>   NEW()          
-1       <v1>   NEW()
-0 > 1   <v2>   NEW(<v0>, <v1>)
-2       <v3>   NEW()          
-{ 2 }   <v3>   COPY           
+0       <v0>: {<: Comparable<Int>}   NEW()
+1       <v1>: Int                    NEW()
+0 > 1   <v2>: Boolean                NEW(<v0>, <v1>)
+2       <v3>: *                      NEW()
+{ 2 }   <v3>: *                      COPY
 =====================
 == dowhile ==
 fun dowhile() {
@@ -17,7 +17,7 @@ fun dowhile() {
     while(0 > 1)
 }
 ---------------------
-0       <v0>   NEW()          
-1       <v1>   NEW()
-0 > 1   <v2>   NEW(<v0>, <v1>)
+0       <v0>: *   NEW()
+1       <v1>: *   NEW()
+0 > 1   <v2>: *   NEW(<v0>, <v1>)
 =====================
diff --git a/compiler/testData/cfg/controlStructures/returnsInWhen.values b/compiler/testData/cfg/controlStructures/returnsInWhen.values
index 6fb7648cce6..f1835c8c05d 100644
--- a/compiler/testData/cfg/controlStructures/returnsInWhen.values
+++ b/compiler/testData/cfg/controlStructures/returnsInWhen.values
@@ -5,6 +5,6 @@ fun illegalWhenBlock(a: Any): Any {
     }
 }
 ---------------------
-a   <v1>   NEW()
-a   <v3>   NEW()
+a   <v1>: *          NEW()
+a   <v3>: {<: Any}   NEW()
 =====================
diff --git a/compiler/testData/cfg/conventions/bothReceivers.instructions b/compiler/testData/cfg/conventions/bothReceivers.instructions
new file mode 100644
index 00000000000..ee01e13b419
--- /dev/null
+++ b/compiler/testData/cfg/conventions/bothReceivers.instructions
@@ -0,0 +1,65 @@
+== Bar ==
+class Bar {
+}
+---------------------
+L0:
+  1 <START>
+L1:
+    <END>      NEXT:[<SINK>]
+error:
+    <ERROR>    PREV:[]
+sink:
+    <SINK>     PREV:[<ERROR>, <END>]
+=====================
+== Foo ==
+class Foo() {
+    fun Bar.invoke() {}
+}
+---------------------
+L0:
+  1 <START>
+L1:
+    <END>      NEXT:[<SINK>]
+error:
+    <ERROR>    PREV:[]
+sink:
+    <SINK>     PREV:[<ERROR>, <END>]
+=====================
+== invoke ==
+fun Bar.invoke() {}
+---------------------
+L0:
+  1 <START>
+  2 mark({})
+    read (Unit)
+L1:
+  1 <END>          NEXT:[<SINK>]
+error:
+    <ERROR>        PREV:[]
+sink:
+    <SINK>         PREV:[<ERROR>, <END>]
+=====================
+== foobar ==
+fun foobar(f: Foo) {
+    Bar().f()
+}
+---------------------
+L0:
+  1 <START>
+    v(f: Foo)
+    magic(f: Foo) -> <v0>
+    w(f|<v0>)
+  2 mark({ Bar().f() })
+    mark(Bar().f())
+    r(f) -> <v1>
+    mark(Bar())
+    call(Bar, <init>) -> <v2>
+    mark(f())
+    call(f, invoke|<v1>, <v2>) -> <v3>
+L1:
+  1 <END>                                 NEXT:[<SINK>]
+error:
+    <ERROR>                               PREV:[]
+sink:
+    <SINK>                                PREV:[<ERROR>, <END>]
+=====================
diff --git a/compiler/testData/cfg/conventions/bothReceivers.kt b/compiler/testData/cfg/conventions/bothReceivers.kt
new file mode 100644
index 00000000000..1ad462cb71d
--- /dev/null
+++ b/compiler/testData/cfg/conventions/bothReceivers.kt
@@ -0,0 +1,10 @@
+class Bar {
+}
+
+class Foo() {
+    fun Bar.invoke() {}
+}
+
+fun foobar(f: Foo) {
+    Bar().f()
+}
\ No newline at end of file
diff --git a/compiler/testData/cfg/conventions/bothReceivers.values b/compiler/testData/cfg/conventions/bothReceivers.values
new file mode 100644
index 00000000000..0e2db937727
--- /dev/null
+++ b/compiler/testData/cfg/conventions/bothReceivers.values
@@ -0,0 +1,26 @@
+== Bar ==
+class Bar {
+}
+---------------------
+=====================
+== Foo ==
+class Foo() {
+    fun Bar.invoke() {}
+}
+---------------------
+=====================
+== invoke ==
+fun Bar.invoke() {}
+---------------------
+=====================
+== foobar ==
+fun foobar(f: Foo) {
+    Bar().f()
+}
+---------------------
+Bar()           <v2>: Bar   NEW()
+f               <v1>: Foo   NEW()
+f()             <v3>: *     NEW(<v1>, <v2>)
+Bar().f()       <v3>: *     COPY
+{ Bar().f() }   <v3>: *     COPY
+=====================
\ No newline at end of file
diff --git a/compiler/testData/cfg/conventions/equals.values b/compiler/testData/cfg/conventions/equals.values
index fde14f3d634..9d4a5bf3270 100644
--- a/compiler/testData/cfg/conventions/equals.values
+++ b/compiler/testData/cfg/conventions/equals.values
@@ -4,7 +4,7 @@ fun foo(a: Int, b: Int) {
     }
 }
 ---------------------
-a        <v2>   NEW()
-b        <v3>   NEW()
-a == b   <v4>   NEW(<v2>, <v3>)
+a        <v2>: OR{{<: Any}, {<: Any}}   NEW()
+b        <v3>: {<: Any?}                NEW()
+a == b   <v4>: Boolean                  NEW(<v2>, <v3>)
 =====================
diff --git a/compiler/testData/cfg/conventions/incrementAtTheEnd.values b/compiler/testData/cfg/conventions/incrementAtTheEnd.values
index af35d135232..daed10577df 100644
--- a/compiler/testData/cfg/conventions/incrementAtTheEnd.values
+++ b/compiler/testData/cfg/conventions/incrementAtTheEnd.values
@@ -4,8 +4,8 @@ fun foo() {
     i++
 }
 ---------------------
-1                   <v0>   NEW()
-i                   <v1>   NEW()
-i++                 <v1>   COPY
-{ var i = 1 i++ }   <v1>   COPY
+1                   <v0>: Int   NEW()
+i                   <v1>: Int   NEW()
+i++                 <v1>: Int   COPY
+{ var i = 1 i++ }   <v1>: Int   COPY
 =====================
diff --git a/compiler/testData/cfg/conventions/invoke.values b/compiler/testData/cfg/conventions/invoke.values
index 448531f5c64..02c3e5b3466 100644
--- a/compiler/testData/cfg/conventions/invoke.values
+++ b/compiler/testData/cfg/conventions/invoke.values
@@ -3,7 +3,7 @@ fun foo(f: () -> Unit) {
     f()
 }
 ---------------------
-f         <v1>   NEW()
-f()       <v2>   NEW(<v1>)
-{ f() }   <v2>   COPY
+f         <v1>: {<: () -> Unit}   NEW()
+f()       <v2>: *                 NEW(<v1>)
+{ f() }   <v2>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/conventions/notEqual.values b/compiler/testData/cfg/conventions/notEqual.values
index 0ec5fe6e8a7..5f758f0157a 100644
--- a/compiler/testData/cfg/conventions/notEqual.values
+++ b/compiler/testData/cfg/conventions/notEqual.values
@@ -3,7 +3,7 @@ fun neq(a: Int, b: Int) {
     if (a != b) {}
 }
 ---------------------
-a        <v2>   NEW()
-b        <v3>   NEW()
-a != b   <v4>   NEW(<v2>, <v3>)
+a        <v2>: OR{{<: Any}, {<: Any}}   NEW()
+b        <v3>: {<: Any?}                NEW()
+a != b   <v4>: Boolean                  NEW(<v2>, <v3>)
 =====================
diff --git a/compiler/testData/cfg/deadCode/DeadCode.values b/compiler/testData/cfg/deadCode/DeadCode.values
index 994dd1d105f..addf7ec3995 100644
--- a/compiler/testData/cfg/deadCode/DeadCode.values
+++ b/compiler/testData/cfg/deadCode/DeadCode.values
@@ -4,7 +4,7 @@ fun test() {
     test()
 }
 ---------------------
-Exception()                    <v0>   NEW()
-test()                         <v1>   NEW()
-{ throw Exception() test() }   <v1>   COPY
+Exception()                    <v0>: {<: Throwable}   NEW()
+test()                         <v1>: *                NEW()
+{ throw Exception() test() }   <v1>: *                COPY
 =====================
diff --git a/compiler/testData/cfg/deadCode/returnInElvis.values b/compiler/testData/cfg/deadCode/returnInElvis.values
index a2105a61f56..0a2dabc4721 100644
--- a/compiler/testData/cfg/deadCode/returnInElvis.values
+++ b/compiler/testData/cfg/deadCode/returnInElvis.values
@@ -3,7 +3,7 @@ fun foo() {
     return ?: null
 }
 ---------------------
-null                 <v0>   NEW()
-return ?: null       <v0>   COPY 
-{ return ?: null }   <v0>   COPY 
+null                 <v0>: *   NEW()
+return ?: null       <v0>: *   COPY
+{ return ?: null }   <v0>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/deadCode/stringTemplate.values b/compiler/testData/cfg/deadCode/stringTemplate.values
index b4c1c1b7c16..280634698cd 100644
--- a/compiler/testData/cfg/deadCode/stringTemplate.values
+++ b/compiler/testData/cfg/deadCode/stringTemplate.values
@@ -3,8 +3,8 @@ fun test() {
     "${throw Exception()} ${1}"
 }
 ---------------------
-Exception()                       <v0>   NEW()
-1                                 <v1>   NEW()
-"${throw Exception()} ${1}"       <v2>   NEW(<v1>)
-{ "${throw Exception()} ${1}" }   <v2>   COPY     
+Exception()                       <v0>: {<: Throwable}   NEW()
+1                                 <v1>: *                NEW()
+"${throw Exception()} ${1}"       <v2>: *                NEW(<v1>)
+{ "${throw Exception()} ${1}" }   <v2>: *                COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.values b/compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.values
index 1f09331a566..886da7ea362 100644
--- a/compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.values
+++ b/compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.values
@@ -15,7 +15,7 @@ class AnonymousInitializers() {
     }
 }
 ---------------------
-34   <v0>   NEW()
-12   <v2>   NEW()
-13   <v4>   NEW()
+34   <v0>: Int   NEW()
+12   <v2>: Int   NEW()
+13   <v4>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.values b/compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.values
index e5a74bb024f..5ac4b35aefe 100644
--- a/compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.values
+++ b/compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.values
@@ -3,8 +3,8 @@ fun foo() {
     {}
 }
 ---------------------
-{}       <v0>   NEW()
-{ {} }   <v0>   COPY 
+{}       <v0>: *   NEW()
+{ {} }   <v0>: *   COPY
 =====================
 == anonymous_0 ==
 {}
diff --git a/compiler/testData/cfg/declarations/functions/FailFunction.values b/compiler/testData/cfg/declarations/functions/FailFunction.values
index 062ee86dcf5..7a6b3c52016 100644
--- a/compiler/testData/cfg/declarations/functions/FailFunction.values
+++ b/compiler/testData/cfg/declarations/functions/FailFunction.values
@@ -3,6 +3,6 @@ fun fail() : Nothing {
   throw java.lang.RuntimeException()
 }
 ---------------------
-RuntimeException()             <v0>   NEW()
-java.lang.RuntimeException()   <v0>   COPY
+RuntimeException()             <v0>: {<: Throwable}   NEW()
+java.lang.RuntimeException()   <v0>: {<: Throwable}   COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/functions/typeParameter.values b/compiler/testData/cfg/declarations/functions/typeParameter.values
index 4ee00400258..ab80f5a4ee4 100644
--- a/compiler/testData/cfg/declarations/functions/typeParameter.values
+++ b/compiler/testData/cfg/declarations/functions/typeParameter.values
@@ -3,6 +3,6 @@ fun <T> foo() {
     T
 }
 ---------------------
-T       <v0>   NEW()
-{ T }   <v0>   COPY 
+T       <v0>: *   NEW()
+{ T }   <v0>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/local/LocalDeclarations.values b/compiler/testData/cfg/declarations/local/LocalDeclarations.values
index 4972ccbbe1b..9c4fe5cf211 100644
--- a/compiler/testData/cfg/declarations/local/LocalDeclarations.values
+++ b/compiler/testData/cfg/declarations/local/LocalDeclarations.values
@@ -17,7 +17,7 @@ class C() {
     }
 }
 ---------------------
-1   <v0>   NEW()
+1   <v0>: Int   NEW()
 =====================
 == doSmth ==
 fun doSmth(i: Int) {}
@@ -33,8 +33,8 @@ fun test1() {
     }
 }
 ---------------------
-1                                   <v1>   NEW()
-object { val x : Int { $x = 1 } }   <v2>   NEW()
+1                                   <v1>: Int                  NEW()
+object { val x : Int { $x = 1 } }   <v2>: <no name provided>   NEW()
 =====================
 == O ==
 object O {
@@ -44,7 +44,7 @@ object O {
     }
 }
 ---------------------
-1   <v1>   NEW()
+1   <v1>: Int   NEW()
 =====================
 == test2 ==
 fun test2() {
@@ -54,9 +54,9 @@ fun test2() {
     }
 }
 ---------------------
-1                      <v0>   NEW()
-b                      <v1>   NEW()
-object { val x = b }   <v2>   NEW()
+1                      <v0>: Int                  NEW()
+b                      <v1>: Int                  NEW()
+object { val x = b }   <v2>: <no name provided>   NEW()
 =====================
 == test3 ==
 fun test3() {
@@ -68,14 +68,14 @@ fun test3() {
     }
 }
 ---------------------
-object { val y : Int fun inner_bar() { y = 10 } }   <v0>   NEW()
+object { val y : Int fun inner_bar() { y = 10 } }   <v0>: <no name provided>   NEW()
 =====================
 == inner_bar ==
 fun inner_bar() {
             y = 10
         }
 ---------------------
-10   <v1>   NEW()
+10   <v1>: Int   NEW()
 =====================
 == test4 ==
 fun test4() {
@@ -91,15 +91,15 @@ fun test4() {
     }
 }
 ---------------------
-1                                                                    <v1>   NEW()
-object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }   <v2>   NEW()
+1                                                                    <v1>: Int                  NEW()
+object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }   <v2>: <no name provided>   NEW()
 =====================
 == ggg ==
 fun ggg() {
             y = 10
         }
 ---------------------
-10   <v1>   NEW()
+10   <v1>: Int   NEW()
 =====================
 == test5 ==
 fun test5() {
@@ -117,21 +117,21 @@ fun test5() {
     }
 }
 ---------------------
-1                                                                         <v0>   NEW()
-2                                                                         <v2>   NEW()
-object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }   <v3>   NEW()
+1                                                                         <v0>: Int                  NEW()
+2                                                                         <v2>: Int                  NEW()
+object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }   <v3>: <no name provided>   NEW()
 =====================
 == foo ==
 fun foo() {
             x = 3
         }
 ---------------------
-3   <v1>   NEW()
+3   <v1>: Int   NEW()
 =====================
 == bar ==
 fun bar() {
             x = 4
         }
 ---------------------
-4   <v1>   NEW()
+4   <v1>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/local/ObjectExpression.values b/compiler/testData/cfg/declarations/local/ObjectExpression.values
index deaf3419903..bf8c6041316 100644
--- a/compiler/testData/cfg/declarations/local/ObjectExpression.values
+++ b/compiler/testData/cfg/declarations/local/ObjectExpression.values
@@ -17,7 +17,7 @@ class B : A {
 == foo ==
 override fun foo() = 10
 ---------------------
-10   <v0>   NEW()
+10   <v0>: Int   NEW()
 =====================
 == foo ==
 fun foo(b: B) : Int {
@@ -25,9 +25,9 @@ fun foo(b: B) : Int {
     return o.foo()
 }
 ---------------------
-b                    <v1>   NEW()
-object : A by b {}   <v2>   NEW()    
-o                    <v3>   NEW()    
-foo()                <v4>   NEW(<v3>)
-o.foo()              <v4>   COPY
+b                    <v1>: *                    NEW()
+object : A by b {}   <v2>: <no name provided>   NEW()
+o                    <v3>: {<: A}               NEW()
+foo()                <v4>: Int                  NEW(<v3>)
+o.foo()              <v4>: Int                  COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/local/localClass.values b/compiler/testData/cfg/declarations/local/localClass.values
index 901eba15d72..4b9ec1b16cd 100644
--- a/compiler/testData/cfg/declarations/local/localClass.values
+++ b/compiler/testData/cfg/declarations/local/localClass.values
@@ -21,12 +21,12 @@ fun f() {
             }
         }
 ---------------------
-""   <v0>   NEW()
+""   <v0>: String   NEW()
 =====================
 == loc ==
 fun loc() {
                 val x3 = ""
             }
 ---------------------
-""   <v0>   NEW()
+""   <v0>: String   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/local/localProperty.values b/compiler/testData/cfg/declarations/local/localProperty.values
index 3f3f9bf7ac5..bd5c69a29c0 100644
--- a/compiler/testData/cfg/declarations/local/localProperty.values
+++ b/compiler/testData/cfg/declarations/local/localProperty.values
@@ -16,5 +16,5 @@ get() {
                 return b
             }
 ---------------------
-b   <v0>   NEW()
+b   <v0>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.values b/compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.values
index 0cf5a4b0acd..99a44889fa0 100644
--- a/compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.values
+++ b/compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.values
@@ -8,12 +8,12 @@ class C {
 == component1 ==
 fun component1() = 1
 ---------------------
-1   <v0>   NEW()
+1   <v0>: Int   NEW()
 =====================
 == component2 ==
 fun component2() = 2
 ---------------------
-2   <v0>   NEW()
+2   <v0>: Int   NEW()
 =====================
 == test ==
 fun test(c: C) {
@@ -21,8 +21,8 @@ fun test(c: C) {
     val d = 1
 }
 ---------------------
-a   <v2>   NEW(<v1>)
-b   <v3>   NEW(<v1>)
-c   <v1>   NEW()
-1   <v4>   NEW()
+a   <v2>: Int   NEW(<v1>)
+b   <v3>: Int   NEW(<v1>)
+c   <v1>: C     NEW()
+1   <v4>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.values b/compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.values
index 71f56d9b567..cad29edf6e3 100644
--- a/compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.values
+++ b/compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.values
@@ -4,7 +4,7 @@ fun foo(x: Int) {
     a
 }
 ---------------------
-x                      <v1>   NEW()
-a                      <v4>   NEW()
-{ val (a, b) = x a }   <v4>   COPY
+x                      <v1>: *   NEW()
+a                      <v4>: *   NEW()
+{ val (a, b) = x a }   <v4>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/properties/DelegatedProperty.values b/compiler/testData/cfg/declarations/properties/DelegatedProperty.values
index 0cb0fefa23e..7197e993c66 100644
--- a/compiler/testData/cfg/declarations/properties/DelegatedProperty.values
+++ b/compiler/testData/cfg/declarations/properties/DelegatedProperty.values
@@ -7,15 +7,15 @@ class Delegate {
 == get ==
 fun get(_this: Any, p: PropertyMetadata): Int = 0
 ---------------------
-0   <v2>   NEW()
+0   <v2>: Int   NEW()
 =====================
 == a ==
 val a = Delegate()
 ---------------------
-Delegate()   <v0>   NEW()
+Delegate()   <v0>: Delegate   NEW()
 =====================
 == b ==
 val b by a
 ---------------------
-a   <v0>   NEW()
+a   <v0>: *   NEW()
 =====================
diff --git a/compiler/testData/cfg/declarations/properties/backingFieldAccess.values b/compiler/testData/cfg/declarations/properties/backingFieldAccess.values
index 1b32ec1b88e..163de356aa2 100644
--- a/compiler/testData/cfg/declarations/properties/backingFieldAccess.values
+++ b/compiler/testData/cfg/declarations/properties/backingFieldAccess.values
@@ -8,6 +8,6 @@ class C {
     }
 }
 ---------------------
-$a       <v1>   NEW(<v0>)
-{ $a }   <v1>   COPY
+$a       <v1>: *   NEW(<v0>)
+{ $a }   <v1>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.values b/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.values
index 1e5f253264f..6c6f52e2a37 100644
--- a/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.values
+++ b/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.values
@@ -8,10 +8,10 @@ abstract class Bar {
 == foo ==
 fun foo() = "foo" + this.$bar
 ---------------------
-"foo"               <v0>   NEW()          
-this                <v1>   COPY
-this                <v1>   NEW()
-$bar                <v2>   NEW(<v1>)      
-this.$bar           <v2>   COPY           
-"foo" + this.$bar   <v3>   NEW(<v0>, <v2>)
+"foo"               <v0>: String      NEW()
+this                <v1>: {<: Bar}    COPY
+this                <v1>: {<: Bar}    NEW()
+$bar                <v2>: {<: Any?}   NEW(<v1>)
+this.$bar           <v2>: {<: Any?}   COPY
+"foo" + this.$bar   <v3>: String      NEW(<v0>, <v2>)
 =====================
diff --git a/compiler/testData/cfg/expressions/Assignments.values b/compiler/testData/cfg/expressions/Assignments.values
index 80cc3e47236..f532d04aa5c 100644
--- a/compiler/testData/cfg/expressions/Assignments.values
+++ b/compiler/testData/cfg/expressions/Assignments.values
@@ -20,28 +20,28 @@ fun assignments() : Unit {
     t.x += 1
 }
 ---------------------
-1                                                                                                                                <v0>    NEW()            
-2                                                                                                                                <v1>    NEW()            
-x                                                                                                                                <v2>    NEW()            
-2                                                                                                                                <v3>    NEW()            
-x += 2                                                                                                                           <v4>    NEW(<v2>, <v3>)  
-true                                                                                                                             <v5>    NEW()            
-1                                                                                                                                <v6>    NEW()            
-2                                                                                                                                <v7>    NEW()            
-if (true) 1 else 2                                                                                                               <v8>    NEW(<v6>, <v7>)  
-true                                                                                                                             <v9>    NEW()            
-false                                                                                                                            <v10>   NEW()            
-true && false                                                                                                                    <v11>   NEW(<v9>, <v10>) 
-false                                                                                                                            <v12>   NEW()            
-true                                                                                                                             <v13>   NEW()            
-false && true                                                                                                                    <v14>   NEW(<v12>, <v13>)
-Test()                                                                                                                           <v15>   NEW()            
-t                                                                                                                                <v16>   NEW()            
-1                                                                                                                                <v17>   NEW()            
-t                                                                                                                                <v22>   NEW()            
-x                                                                                                                                <v19>   NEW(<v18>)       
-t.x                                                                                                                              <v19>   COPY             
-1                                                                                                                                <v20>   NEW()            
-t.x += 1                                                                                                                         <v21>   NEW(<v19>, <v20>)
-{ var x = 1 x = 2 x += 2 x = if (true) 1 else 2 val y = true && false val z = false && true val t = Test(); t.x = 1 t.x += 1 }   <v21>   COPY             
+1                                                                                                                                <v0>: Int        NEW()            
+2                                                                                                                                <v1>: Int        NEW()            
+x                                                                                                                                <v2>: Int        NEW()            
+2                                                                                                                                <v3>: Int        NEW()            
+x += 2                                                                                                                           <v4>: Int        NEW(<v2>, <v3>)  
+true                                                                                                                             <v5>: Boolean    NEW()            
+1                                                                                                                                <v6>: Int        NEW()            
+2                                                                                                                                <v7>: Int        NEW()            
+if (true) 1 else 2                                                                                                               <v8>: Int        NEW(<v6>, <v7>)  
+true                                                                                                                             <v9>: Boolean    NEW()            
+false                                                                                                                            <v10>: Boolean   NEW()            
+true && false                                                                                                                    <v11>: Boolean   NEW(<v9>, <v10>) 
+false                                                                                                                            <v12>: Boolean   NEW()            
+true                                                                                                                             <v13>: Boolean   NEW()            
+false && true                                                                                                                    <v14>: Boolean   NEW(<v12>, <v13>)
+Test()                                                                                                                           <v15>: Test      NEW()            
+t                                                                                                                                <v16>: Test      NEW()            
+1                                                                                                                                <v17>: Int       NEW()            
+t                                                                                                                                <v22>: Test      NEW()            
+x                                                                                                                                <v19>: Int       NEW(<v18>)       
+t.x                                                                                                                              <v19>: Int       COPY             
+1                                                                                                                                <v20>: Int       NEW()            
+t.x += 1                                                                                                                         <v21>: Int       NEW(<v19>, <v20>)
+{ var x = 1 x = 2 x += 2 x = if (true) 1 else 2 val y = true && false val z = false && true val t = Test(); t.x = 1 t.x += 1 }   <v21>: Int       COPY             
 =====================
diff --git a/compiler/testData/cfg/expressions/LazyBooleans.values b/compiler/testData/cfg/expressions/LazyBooleans.values
index fcd696e1030..b432c87df86 100644
--- a/compiler/testData/cfg/expressions/LazyBooleans.values
+++ b/compiler/testData/cfg/expressions/LazyBooleans.values
@@ -17,34 +17,34 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
     14
 }
 ---------------------
-a                                                                                                             <v2>    NEW()            
-1                                                                                                             <v3>    NEW()            
-{ 1 }                                                                                                         <v3>    COPY             
-2                                                                                                             <v4>    NEW()            
-{ 2 }                                                                                                         <v4>    COPY             
-if (a) { 1 } else { 2 }                                                                                       <v5>    NEW(<v3>, <v4>)  
-3                                                                                                             <v6>    NEW()            
-a                                                                                                             <v7>    NEW()            
-b                                                                                                             <v8>    NEW()            
-a && b                                                                                                        <v9>    NEW(<v7>, <v8>)  
-5                                                                                                             <v10>   NEW()            
-6                                                                                                             <v11>   NEW()            
-if (a && b) 5 else 6                                                                                          <v12>   NEW(<v10>, <v11>)
-7                                                                                                             <v13>   NEW()            
-a                                                                                                             <v14>   NEW()            
-b                                                                                                             <v15>   NEW()            
-a || b                                                                                                        <v16>   NEW(<v14>, <v15>)
-8                                                                                                             <v17>   NEW()            
-9                                                                                                             <v18>   NEW()            
-if (a || b) 8 else 9                                                                                          <v19>   NEW(<v17>, <v18>)
-10                                                                                                            <v20>   NEW()            
-a                                                                                                             <v21>   NEW()            
-11                                                                                                            <v22>   NEW()            
-if (a) 11                                                                                                     <v22>   COPY             
-12                                                                                                            <v23>   NEW()            
-a                                                                                                             <v24>   NEW()            
-13                                                                                                            <v25>   NEW()            
-if (a) else 13                                                                                                <v25>   COPY             
-14                                                                                                            <v26>   NEW()            
-{ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 }   <v26>   COPY             
+a                                                                                                             <v2>: Boolean    NEW()            
+1                                                                                                             <v3>: *          NEW()            
+{ 1 }                                                                                                         <v3>: *          COPY             
+2                                                                                                             <v4>: *          NEW()            
+{ 2 }                                                                                                         <v4>: *          COPY             
+if (a) { 1 } else { 2 }                                                                                       <v5>: *          NEW(<v3>, <v4>)  
+3                                                                                                             <v6>: *          NEW()            
+a                                                                                                             <v7>: Boolean    NEW()            
+b                                                                                                             <v8>: Boolean    NEW()            
+a && b                                                                                                        <v9>: Boolean    NEW(<v7>, <v8>)  
+5                                                                                                             <v10>: *         NEW()            
+6                                                                                                             <v11>: *         NEW()            
+if (a && b) 5 else 6                                                                                          <v12>: *         NEW(<v10>, <v11>)
+7                                                                                                             <v13>: *         NEW()            
+a                                                                                                             <v14>: Boolean   NEW()            
+b                                                                                                             <v15>: Boolean   NEW()            
+a || b                                                                                                        <v16>: Boolean   NEW(<v14>, <v15>)
+8                                                                                                             <v17>: *         NEW()            
+9                                                                                                             <v18>: *         NEW()            
+if (a || b) 8 else 9                                                                                          <v19>: *         NEW(<v17>, <v18>)
+10                                                                                                            <v20>: *         NEW()            
+a                                                                                                             <v21>: Boolean   NEW()            
+11                                                                                                            <v22>: *         NEW()            
+if (a) 11                                                                                                     <v22>: *         COPY             
+12                                                                                                            <v23>: *         NEW()            
+a                                                                                                             <v24>: Boolean   NEW()            
+13                                                                                                            <v25>: *         NEW()            
+if (a) else 13                                                                                                <v25>: *         COPY             
+14                                                                                                            <v26>: *         NEW()            
+{ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 }   <v26>: *         COPY             
 =====================
diff --git a/compiler/testData/cfg/expressions/ReturnFromExpression.values b/compiler/testData/cfg/expressions/ReturnFromExpression.values
index fefb44006b9..dc871c3aa57 100644
--- a/compiler/testData/cfg/expressions/ReturnFromExpression.values
+++ b/compiler/testData/cfg/expressions/ReturnFromExpression.values
@@ -3,8 +3,8 @@ fun blockAndAndMismatch() : Boolean {
   false || (return false)
 }
 ---------------------
-false                         <v0>   NEW()    
-false                         <v1>   NEW()    
-false || (return false)       <v2>   NEW(<v0>)
-{ false || (return false) }   <v2>   COPY     
+false                         <v0>: Boolean   NEW()
+false                         <v1>: Boolean   NEW()
+false || (return false)       <v2>: *         NEW(<v0>)
+{ false || (return false) }   <v2>: *         COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/assignmentToThis.values b/compiler/testData/cfg/expressions/assignmentToThis.values
index 45d0ff07d35..2571d44967f 100644
--- a/compiler/testData/cfg/expressions/assignmentToThis.values
+++ b/compiler/testData/cfg/expressions/assignmentToThis.values
@@ -3,5 +3,5 @@ fun Int.bar(c: C) {
     this = c
 }
 ---------------------
-c   <v1>   NEW()
+c   <v1>: *   NEW()
 =====================
diff --git a/compiler/testData/cfg/expressions/chainedQualifiedExpression.values b/compiler/testData/cfg/expressions/chainedQualifiedExpression.values
index 54a5ded8e24..03ec485f499 100644
--- a/compiler/testData/cfg/expressions/chainedQualifiedExpression.values
+++ b/compiler/testData/cfg/expressions/chainedQualifiedExpression.values
@@ -50,141 +50,141 @@ public open class JetKeywordCompletionContributor() {
     }
 }
 ---------------------
-1.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v0>     NEW()                                        
-BunchKeywordRegister()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v2>     NEW(<v1>)                                    
-ABSTRACT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v3>     NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v4>     NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v5>     NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v6>     NEW()                                        
-add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v7>     NEW(<v2>, <v3>, <v4>, <v5>, <v6>)            
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v7>     COPY                                         
-FINAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v8>     NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v9>     NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v10>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v11>    NEW()                                        
-add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v12>    NEW(<v7>, <v8>, <v9>, <v10>, <v11>)          
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v12>    COPY                                         
-OPEN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v13>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v14>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v15>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v16>    NEW()                                        
-add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v17>    NEW(<v12>, <v13>, <v14>, <v15>, <v16>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v17>    COPY                                         
-INTERNAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v18>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v19>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v20>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v21>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v22>    NEW()                                        
-add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v23>    NEW(<v17>, <v18>, <v19>, <v20>, <v21>, <v22>)
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v23>    COPY                                         
-PRIVATE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v24>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v25>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v26>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v27>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v28>    NEW()                                        
-add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v29>    NEW(<v23>, <v24>, <v25>, <v26>, <v27>, <v28>)
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v29>    COPY                                         
-PROTECTED_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v30>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v31>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v32>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v33>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v34>    NEW()                                        
-add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v35>    NEW(<v29>, <v30>, <v31>, <v32>, <v33>, <v34>)
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v35>    COPY                                         
-PUBLIC_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v36>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v37>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v38>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v39>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v40>    NEW()                                        
-add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v41>    NEW(<v35>, <v36>, <v37>, <v38>, <v39>, <v40>)
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v41>    COPY                                         
-CLASS_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v42>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v43>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v44>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v45>    NEW()                                        
-add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v46>    NEW(<v41>, <v42>, <v43>, <v44>, <v45>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <v46>    COPY                                         
-ENUM_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v47>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v48>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v49>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v50>    NEW()                                        
-add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v51>    NEW(<v46>, <v47>, <v48>, <v49>, <v50>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v51>    COPY                                         
-FUN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v52>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v53>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v54>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v55>    NEW()                                        
-add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v56>    NEW(<v51>, <v52>, <v53>, <v54>, <v55>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v56>    COPY                                         
-GET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v57>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v58>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v59>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v60>    NEW()                                        
-add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v61>    NEW(<v56>, <v57>, <v58>, <v59>, <v60>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v61>    COPY                                         
-SET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v62>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v63>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v64>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v65>    NEW()                                        
-add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v66>    NEW(<v61>, <v62>, <v63>, <v64>, <v65>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v66>    COPY                                         
-TRAIT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v67>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v68>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v69>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v70>    NEW()                                        
-add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v71>    NEW(<v66>, <v67>, <v68>, <v69>, <v70>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                <v71>    COPY                                         
-VAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v72>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v73>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v74>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v75>    NEW()                                        
-add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v76>    NEW(<v71>, <v72>, <v73>, <v74>, <v75>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                          <v76>    COPY                                         
-VAR_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v77>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v78>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v79>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v80>    NEW()                                        
-add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v81>    NEW(<v76>, <v77>, <v78>, <v79>, <v80>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                    <v81>    COPY                                         
-TYPE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v82>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v83>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v84>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v85>    NEW()                                        
-add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v86>    NEW(<v81>, <v82>, <v83>, <v84>, <v85>)       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                             <v86>    COPY                                         
-IMPORT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v87>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v88>    NEW()                                        
-add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v89>    NEW(<v86>, <v87>, <v88>)                     
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                            <v89>    COPY                                         
-PACKAGE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v90>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v91>    NEW()                                        
-add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v92>    NEW(<v89>, <v90>, <v91>)                     
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                          <v92>    COPY                                         
-OVERRIDE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v93>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v94>    NEW()                                        
-add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v95>    NEW(<v92>, <v93>, <v94>)                     
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                       <v95>    COPY                                         
-IN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v96>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v97>    NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v98>    NEW()                                        
-add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v99>    NEW(<v95>, <v96>, <v97>, <v98>)              
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                              <v99>    COPY                                         
-OUT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v100>   NEW()                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v101>   NEW()                                        
-add(OUT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v102>   NEW(<v99>, <v100>, <v101>)                   
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel)                                                                                <v102>   COPY                                         
-OBJECT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v103>   NEW()                                        
-unresolvedCode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v104>   NEW()                                        
-add(OBJECT_KEYWORD, unresolvedCode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v105>   NEW(<v102>, <v103>, <v104>)                  
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode)                                           <v105>   COPY                                         
-registerAll()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v106>   NEW(<v105>)                                  
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll()                            <v106>   COPY                                         
-{ val inTopLevel = 1.0 BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll() }   <v106>   COPY                                         
+1.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v0>: Double                                                   NEW()                                        
+BunchKeywordRegister()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v2>: JetKeywordCompletionContributor.BunchKeywordRegister     NEW(<v1>)                                    
+ABSTRACT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v3>: {<: [ERROR : Type annotation was missing]}               NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v4>: Double                                                   NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v5>: Double                                                   NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v6>: Double                                                   NEW()                                        
+add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v7>: JetKeywordCompletionContributor.BunchKeywordRegister     NEW(<v2>, <v3>, <v4>, <v5>, <v6>)            
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v7>: JetKeywordCompletionContributor.BunchKeywordRegister     COPY                                         
+FINAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v8>: {<: [ERROR : Type annotation was missing]}               NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v9>: Double                                                   NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v10>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v11>: Double                                                  NEW()                                        
+add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v12>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v7>, <v8>, <v9>, <v10>, <v11>)          
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v12>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+OPEN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v13>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v14>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v15>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v16>: Double                                                  NEW()                                        
+add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v17>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v12>, <v13>, <v14>, <v15>, <v16>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v17>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+INTERNAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v18>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v19>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v20>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v21>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v22>: Double                                                  NEW()                                        
+add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v23>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v17>, <v18>, <v19>, <v20>, <v21>, <v22>)
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v23>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+PRIVATE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v24>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v25>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v26>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v27>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v28>: Double                                                  NEW()                                        
+add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v29>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v23>, <v24>, <v25>, <v26>, <v27>, <v28>)
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v29>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+PROTECTED_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v30>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v31>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v32>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v33>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v34>: Double                                                  NEW()                                        
+add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v35>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v29>, <v30>, <v31>, <v32>, <v33>, <v34>)
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v35>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+PUBLIC_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v36>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v37>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v38>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v39>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v40>: Double                                                  NEW()                                        
+add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v41>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v35>, <v36>, <v37>, <v38>, <v39>, <v40>)
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v41>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+CLASS_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v42>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v43>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v44>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v45>: Double                                                  NEW()                                        
+add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v46>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v41>, <v42>, <v43>, <v44>, <v45>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <v46>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+ENUM_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v47>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v48>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v49>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v50>: Double                                                  NEW()                                        
+add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v51>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v46>, <v47>, <v48>, <v49>, <v50>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v51>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+FUN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v52>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v53>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v54>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v55>: Double                                                  NEW()                                        
+add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v56>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v51>, <v52>, <v53>, <v54>, <v55>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v56>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+GET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v57>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v58>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v59>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v60>: Double                                                  NEW()                                        
+add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v61>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v56>, <v57>, <v58>, <v59>, <v60>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v61>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+SET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v62>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v63>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v64>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v65>: Double                                                  NEW()                                        
+add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v66>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v61>, <v62>, <v63>, <v64>, <v65>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v66>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+TRAIT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v67>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v68>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v69>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v70>: Double                                                  NEW()                                        
+add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v71>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v66>, <v67>, <v68>, <v69>, <v70>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                <v71>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+VAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v72>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v73>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v74>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v75>: Double                                                  NEW()                                        
+add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v76>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v71>, <v72>, <v73>, <v74>, <v75>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                          <v76>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+VAR_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v77>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v78>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v79>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v80>: Double                                                  NEW()                                        
+add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v81>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v76>, <v77>, <v78>, <v79>, <v80>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                    <v81>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+TYPE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v82>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v83>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v84>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v85>: Double                                                  NEW()                                        
+add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v86>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v81>, <v82>, <v83>, <v84>, <v85>)       
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                             <v86>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+IMPORT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v87>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v88>: Double                                                  NEW()                                        
+add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v89>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v86>, <v87>, <v88>)                     
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                            <v89>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+PACKAGE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v90>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v91>: Double                                                  NEW()                                        
+add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v92>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v89>, <v90>, <v91>)                     
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                          <v92>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+OVERRIDE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v93>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v94>: Double                                                  NEW()                                        
+add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v95>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v92>, <v93>, <v94>)                     
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                       <v95>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+IN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v96>: {<: [ERROR : Type annotation was missing]}              NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v97>: Double                                                  NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v98>: Double                                                  NEW()                                        
+add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v99>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW(<v95>, <v96>, <v97>, <v98>)              
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                              <v99>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                         
+OUT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v100>: {<: [ERROR : Type annotation was missing]}             NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v101>: Double                                                 NEW()                                        
+add(OUT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v102>: JetKeywordCompletionContributor.BunchKeywordRegister   NEW(<v99>, <v100>, <v101>)                   
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel)                                                                                <v102>: JetKeywordCompletionContributor.BunchKeywordRegister   COPY                                         
+OBJECT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v103>: {<: [ERROR : Type annotation was missing]}             NEW()                                        
+unresolvedCode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v104>: Double                                                 NEW()                                        
+add(OBJECT_KEYWORD, unresolvedCode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v105>: JetKeywordCompletionContributor.BunchKeywordRegister   NEW(<v102>, <v103>, <v104>)                  
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode)                                           <v105>: JetKeywordCompletionContributor.BunchKeywordRegister   COPY                                         
+registerAll()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v106>: *                                                      NEW(<v105>)
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll()                            <v106>: *                                                      COPY
+{ val inTopLevel = 1.0 BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll() }   <v106>: *                                                      COPY
 =====================
 == ABSTRACT_KEYWORD ==
 val ABSTRACT_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == FINAL_KEYWORD ==
 val FINAL_KEYWORD OPEN_KEYWORD = JetToken()
@@ -193,100 +193,100 @@ val FINAL_KEYWORD OPEN_KEYWORD = JetToken()
 == OPEN_KEYWORD ==
 val OPEN_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == INTERNAL_KEYWORD ==
 val INTERNAL_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == PRIVATE_KEYWORD ==
 val PRIVATE_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == PROTECTED_KEYWORD ==
 val PROTECTED_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == PUBLIC_KEYWORD ==
 val PUBLIC_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == CLASS_KEYWORD ==
 val CLASS_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == ENUM_KEYWORD ==
 val ENUM_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == FUN_KEYWORD ==
 val FUN_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == GET_KEYWORD ==
 val GET_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == SET_KEYWORD ==
 val SET_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == TRAIT_KEYWORD ==
 val TRAIT_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == VAL_KEYWORD ==
 val VAL_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == VAR_KEYWORD ==
 val VAR_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == TYPE_KEYWORD ==
 val TYPE_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == IMPORT_KEYWORD ==
 val IMPORT_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == PACKAGE_KEYWORD ==
 val PACKAGE_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == OVERRIDE_KEYWORD ==
 val OVERRIDE_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == IN_KEYWORD ==
 val IN_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == OUT_KEYWORD ==
 val OUT_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
 == OBJECT_KEYWORD ==
 val OBJECT_KEYWORD = JetToken()
 ---------------------
-JetToken()   <v0>   NEW()
+JetToken()   <v0>: JetToken   NEW()
 =====================
diff --git a/compiler/testData/cfg/expressions/expressionAsFunction.values b/compiler/testData/cfg/expressions/expressionAsFunction.values
index 2d458dfdcc0..52a6534275b 100644
--- a/compiler/testData/cfg/expressions/expressionAsFunction.values
+++ b/compiler/testData/cfg/expressions/expressionAsFunction.values
@@ -3,8 +3,8 @@ fun invoke(f: () -> Unit) {
     (f)()
 }
 ---------------------
-f           <v1>   NEW()
-(f)         <v1>   COPY
-(f)()       <v2>   NEW(<v1>)
-{ (f)() }   <v2>   COPY
+f           <v1>: {<: () -> Unit}   NEW()
+(f)         <v1>: {<: () -> Unit}   COPY
+(f)()       <v2>: *                 NEW(<v1>)
+{ (f)() }   <v2>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/incdec.values b/compiler/testData/cfg/expressions/incdec.values
index f593461f745..060a72f960d 100644
--- a/compiler/testData/cfg/expressions/incdec.values
+++ b/compiler/testData/cfg/expressions/incdec.values
@@ -13,18 +13,18 @@ fun foo() {
     bar(--a)
 }
 ---------------------
-1                                                   <v0>    NEW()
-a                                                   <v1>    NEW()
-a++                                                 <v1>    COPY
-bar(a++)                                            <v3>    NEW(<v1>)
-a                                                   <v4>    NEW()
-a--                                                 <v4>    COPY
-bar(a--)                                            <v6>    NEW(<v4>)
-a                                                   <v7>    NEW()
-++a                                                 <v8>    NEW(<v7>)
-bar(++a)                                            <v9>    NEW(<v8>)
-a                                                   <v10>   NEW()
---a                                                 <v11>   NEW(<v10>)
-bar(--a)                                            <v12>   NEW(<v11>)
-{ var a = 1 bar(a++) bar(a--) bar(++a) bar(--a) }   <v12>   COPY
-=====================
\ No newline at end of file
+1                                                   <v0>: Int    NEW()     
+a                                                   <v1>: Int    NEW()     
+a++                                                 <v1>: Int    COPY      
+bar(a++)                                            <v3>: *      NEW(<v1>) 
+a                                                   <v4>: Int    NEW()     
+a--                                                 <v4>: Int    COPY      
+bar(a--)                                            <v6>: *      NEW(<v4>) 
+a                                                   <v7>: Int    NEW()     
+++a                                                 <v8>: Int    NEW(<v7>) 
+bar(++a)                                            <v9>: *      NEW(<v8>) 
+a                                                   <v10>: Int   NEW()     
+--a                                                 <v11>: Int   NEW(<v10>)
+bar(--a)                                            <v12>: *     NEW(<v11>)
+{ var a = 1 bar(a++) bar(a--) bar(++a) bar(--a) }   <v12>: *     COPY      
+=====================
diff --git a/compiler/testData/cfg/expressions/nothingExpr.values b/compiler/testData/cfg/expressions/nothingExpr.values
index 11eb2496563..4cd3916aecd 100644
--- a/compiler/testData/cfg/expressions/nothingExpr.values
+++ b/compiler/testData/cfg/expressions/nothingExpr.values
@@ -5,7 +5,7 @@ fun Any?.doSomething() {}
 == bar ==
 fun bar(): Nothing = throw Exception()
 ---------------------
-Exception()   <v0>   NEW()
+Exception()   <v0>: {<: Throwable}   NEW()
 =====================
 == foo ==
 fun foo() {
@@ -13,11 +13,11 @@ fun foo() {
     bar().doSomething
 }
 ---------------------
-null                                         <v0>   NEW()    
-null!!                                       <v1>   NEW(<v0>)
-doSomething()                                <v2>   NEW(<v1>)
-null!!.doSomething()                         <v2>   COPY
-doSomething                                  <v3>   NEW()    
-bar().doSomething                            <v3>   COPY     
-{ null!!.doSomething() bar().doSomething }   <v3>   COPY     
+null                                         <v0>: *   NEW()    
+null!!                                       <v1>: *   NEW(<v0>)
+doSomething()                                <v2>: *   NEW(<v1>)
+null!!.doSomething()                         <v2>: *   COPY     
+doSomething                                  <v3>: *   NEW()    
+bar().doSomething                            <v3>: *   COPY     
+{ null!!.doSomething() bar().doSomething }   <v3>: *   COPY     
 =====================
diff --git a/compiler/testData/cfg/expressions/propertySafeCall.values b/compiler/testData/cfg/expressions/propertySafeCall.values
index 80da9017c57..a288285f8f4 100644
--- a/compiler/testData/cfg/expressions/propertySafeCall.values
+++ b/compiler/testData/cfg/expressions/propertySafeCall.values
@@ -3,8 +3,8 @@ fun test(s: String?) {
     s?.length
 }
 ---------------------
-s               <v1>   NEW()
-length          <v2>   NEW(<v1>)
-s?.length       <v2>   COPY     
-{ s?.length }   <v2>   COPY     
+s               <v1>: {<: CharSequence?}   NEW()
+length          <v2>: *                    NEW(<v1>)
+s?.length       <v2>: *                    COPY
+{ s?.length }   <v2>: *                    COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.values b/compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.values
index 8ac8e57cef1..71888c1db6a 100644
--- a/compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.values
+++ b/compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.values
@@ -3,7 +3,7 @@ fun foo(s: String) {
     s.
 }
 ---------------------
-s        <v1>   NEW()
-s.       <v2>   NEW(<v1>)
-{ s. }   <v2>   COPY
+s        <v1>: *   NEW()
+s.       <v2>: *   NEW(<v1>)
+{ s. }   <v2>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/thisExpression.values b/compiler/testData/cfg/expressions/thisExpression.values
index 36c7359fc2e..a1db0a07d38 100644
--- a/compiler/testData/cfg/expressions/thisExpression.values
+++ b/compiler/testData/cfg/expressions/thisExpression.values
@@ -3,6 +3,6 @@ fun Function0<Unit>.foo() {
     this()
 }
 ---------------------
-this()       <v0>   NEW()
-{ this() }   <v0>   COPY
+this()       <v0>: *   NEW()
+{ this() }   <v0>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/unresolvedCall.values b/compiler/testData/cfg/expressions/unresolvedCall.values
index 54739cc2bc7..e7c190cc644 100644
--- a/compiler/testData/cfg/expressions/unresolvedCall.values
+++ b/compiler/testData/cfg/expressions/unresolvedCall.values
@@ -3,8 +3,8 @@ fun test(a: Any) {
     a.foo()
 }
 ---------------------
-a             <v1>   NEW()
-foo()         <v2>   NEW(<v1>)
-a.foo()       <v2>   COPY
-{ a.foo() }   <v2>   COPY     
+a             <v1>: *   NEW()
+foo()         <v2>: *   NEW(<v1>)
+a.foo()       <v2>: *   COPY
+{ a.foo() }   <v2>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/unresolvedProperty.values b/compiler/testData/cfg/expressions/unresolvedProperty.values
index 242d96f7738..a9903e08e05 100644
--- a/compiler/testData/cfg/expressions/unresolvedProperty.values
+++ b/compiler/testData/cfg/expressions/unresolvedProperty.values
@@ -3,8 +3,8 @@ fun test(a: Any) {
     a.foo
 }
 ---------------------
-a           <v1>   NEW()
-foo         <v2>   NEW(<v1>)
-a.foo       <v2>   COPY     
-{ a.foo }   <v2>   COPY     
+a           <v1>: *   NEW()
+foo         <v2>: *   NEW(<v1>)
+a.foo       <v2>: *   COPY
+{ a.foo }   <v2>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/unusedExpressionSimpleName.values b/compiler/testData/cfg/expressions/unusedExpressionSimpleName.values
index 21c1d285846..6e60c264f8f 100644
--- a/compiler/testData/cfg/expressions/unusedExpressionSimpleName.values
+++ b/compiler/testData/cfg/expressions/unusedExpressionSimpleName.values
@@ -3,6 +3,6 @@ fun main(arg : Array<String>) {
     a
 }
 ---------------------
-a       <v1>   NEW()
-{ a }   <v1>   COPY
+a       <v1>: *   NEW()
+{ a }   <v1>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/functions/DefaultValuesForArguments.values b/compiler/testData/cfg/functions/DefaultValuesForArguments.values
index ce90d8c6d3c..1f17659350c 100644
--- a/compiler/testData/cfg/functions/DefaultValuesForArguments.values
+++ b/compiler/testData/cfg/functions/DefaultValuesForArguments.values
@@ -1,9 +1,9 @@
 == foo ==
 fun foo(i: Int = 1, j: Int) = i + j
 ---------------------
-1            <v0>   NEW()          
-i: Int = 1   <v2>   NEW(<v0>, <v1>)
-i            <v4>   NEW()          
-j            <v5>   NEW()          
-i + j        <v6>   NEW(<v4>, <v5>)
+1            <v0>: Int   NEW()
+i: Int = 1   <v2>: Int   NEW(<v0>, <v1>)
+i            <v4>: Int   NEW()
+j            <v5>: Int   NEW()
+i + j        <v6>: Int   NEW(<v4>, <v5>)
 =====================
diff --git a/compiler/testData/cfg/tailCalls/finally.values b/compiler/testData/cfg/tailCalls/finally.values
index 3c892f5ed05..164bdd47631 100644
--- a/compiler/testData/cfg/tailCalls/finally.values
+++ b/compiler/testData/cfg/tailCalls/finally.values
@@ -7,6 +7,6 @@ tailRecursive fun test() : Int {
     }
 }
 ---------------------
-test()       <v0>   NEW()
-{ test() }   <v0>   COPY
+test()       <v0>: *   NEW()
+{ test() }   <v0>: *   COPY
 =====================
diff --git a/compiler/testData/cfg/tailCalls/finallyWithReturn.values b/compiler/testData/cfg/tailCalls/finallyWithReturn.values
index ae6a6469285..11c80464648 100644
--- a/compiler/testData/cfg/tailCalls/finallyWithReturn.values
+++ b/compiler/testData/cfg/tailCalls/finallyWithReturn.values
@@ -7,5 +7,5 @@ tailRecursive fun test() : Int {
     }
 }
 ---------------------
-test()   <v0>   NEW()
+test()   <v0>: Int   NEW()
 =====================
diff --git a/compiler/testData/cfg/tailCalls/sum.values b/compiler/testData/cfg/tailCalls/sum.values
index 89681b86d73..7df26749973 100644
--- a/compiler/testData/cfg/tailCalls/sum.values
+++ b/compiler/testData/cfg/tailCalls/sum.values
@@ -4,17 +4,17 @@ tailRecursive fun sum(x: Long, sum: Long): Long {
     return sum(x - 1, sum + x)
 }
 ---------------------
-x                     <v2>    NEW()
-0                     <v3>    NEW()
-toLong()              <v4>    NEW(<v3>)
-0.toLong()            <v4>    COPY
-x == 0.toLong()       <v5>    NEW(<v2>, <v4>)
-sum                   <v6>    NEW()            
-x                     <v7>    NEW()
-1                     <v8>    NEW()
-x - 1                 <v9>    NEW(<v7>, <v8>)
-sum                   <v10>   NEW()            
-x                     <v11>   NEW()
-sum + x               <v12>   NEW(<v10>, <v11>)
-sum(x - 1, sum + x)   <v13>   NEW(<v9>, <v12>)
+x                     <v2>: OR{{<: Any}, {<: Any}}   NEW()
+0                     <v3>: {<: Number}              NEW()
+toLong()              <v4>: {<: Any?}                NEW(<v3>)
+0.toLong()            <v4>: {<: Any?}                COPY
+x == 0.toLong()       <v5>: Boolean                  NEW(<v2>, <v4>)
+sum                   <v6>: Long                     NEW()
+x                     <v7>: Long                     NEW()
+1                     <v8>: Int                      NEW()
+x - 1                 <v9>: Long                     NEW(<v7>, <v8>)
+sum                   <v10>: Long                    NEW()
+x                     <v11>: Long                    NEW()
+sum + x               <v12>: Long                    NEW(<v10>, <v11>)
+sum(x - 1, sum + x)   <v13>: Long                    NEW(<v9>, <v12>)
 =====================
diff --git a/compiler/testData/cfg/tailCalls/try.values b/compiler/testData/cfg/tailCalls/try.values
index 8605d77c651..269ddaa7c86 100644
--- a/compiler/testData/cfg/tailCalls/try.values
+++ b/compiler/testData/cfg/tailCalls/try.values
@@ -7,5 +7,5 @@ tailRecursive fun foo() {
     }
 }
 ---------------------
-foo()   <v0>   NEW()
+foo()   <v0>: Unit   NEW()
 =====================
diff --git a/compiler/testData/cfg/tailCalls/tryCatchFinally.values b/compiler/testData/cfg/tailCalls/tryCatchFinally.values
index e555ef8ad11..08302009127 100644
--- a/compiler/testData/cfg/tailCalls/tryCatchFinally.values
+++ b/compiler/testData/cfg/tailCalls/tryCatchFinally.values
@@ -9,12 +9,12 @@ fun test() : Unit {
     }
 }
 ---------------------
-test()                                                                     <v0>   NEW()
-{ test() }                                                                 <v0>   COPY
-test()                                                                     <v2>   NEW()
-{ test() }                                                                 <v2>   COPY
-test()                                                                     <v3>   NEW()
-{ test() }                                                                 <v3>   COPY
-try { test() } catch (any : Exception) { test() } finally { test() }       <v4>   NEW(<v0>, <v2>)
-{ try { test() } catch (any : Exception) { test() } finally { test() } }   <v4>   COPY           
+test()                                                                     <v0>: *   NEW()          
+{ test() }                                                                 <v0>: *   COPY           
+test()                                                                     <v2>: *   NEW()          
+{ test() }                                                                 <v2>: *   COPY           
+test()                                                                     <v3>: *   NEW()          
+{ test() }                                                                 <v3>: *   COPY           
+try { test() } catch (any : Exception) { test() } finally { test() }       <v4>: *   NEW(<v0>, <v2>)
+{ try { test() } catch (any : Exception) { test() } finally { test() } }   <v4>: *   COPY           
 =====================
diff --git a/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudoValueTest.kt b/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudoValueTest.kt
index f795983e262..f980f195c5b 100644
--- a/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudoValueTest.kt
+++ b/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudoValueTest.kt
@@ -22,9 +22,15 @@ import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.lang.psi.JetTreeVisitorVoid
 import org.jetbrains.jet.lang.resolve.BindingContext
 import java.util.*
+import org.jetbrains.jet.lang.cfg.pseudocode.collectValueUsages
+import org.jetbrains.jet.lang.cfg.pseudocode.TypePredicate
+import org.jetbrains.jet.lang.cfg.pseudocode.getExpectedTypePredicate
 
 public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
     override fun dumpInstructions(pseudocode: PseudocodeImpl, out: StringBuilder, bindingContext: BindingContext) {
+        val valueUsageMap = pseudocode.collectValueUsages()
+        val expectedTypePredicateMap = HashMap<PseudoValue, TypePredicate>()
+
         fun getElementToValueMap(pseudocode: PseudocodeImpl): Map<JetElement, PseudoValue> {
             val elementToValues = LinkedHashMap<JetElement, PseudoValue>()
             pseudocode.getCorrespondingElement().accept(object : JetTreeVisitorVoid() {
@@ -44,6 +50,11 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
 
         fun elementText(element: JetElement): String = element.getText()!!.replaceAll("\\s+", " ")
 
+        fun valueDecl(value: PseudoValue): String {
+            val typePredicate = expectedTypePredicateMap.getOrPut(value) { getExpectedTypePredicate(value, valueUsageMap, bindingContext) }
+            return "${value.debugName}: $typePredicate"
+        }
+
         fun valueDescription(element: JetElement, value: PseudoValue): String {
             return if (value.element != element) "COPY" else "NEW${value.createdAt.inputValues.makeString(", ", "(", ")")}"
         }
@@ -52,14 +63,14 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
         if (elementToValues.isEmpty()) return
 
         val elementColumnWidth = elementToValues.keySet().map { elementText(it).length() }.max()!!
-        val valueColumnWidth = elementToValues.values().map { it.debugName.length() }.max()!!
+        val valueColumnWidth = elementToValues.values().map { valueDecl(it).length() }.max()!!
         val valueDescColumnWidth = elementToValues.entrySet().map { valueDescription(it.key, it.value).length }.max()!!
 
         for ((element, value) in elementToValues.entrySet()) {
             out
                     .append("%1$-${elementColumnWidth}s".format(elementText(element)))
                     .append("   ")
-                    .append("%1$-${valueColumnWidth}s".format(value.debugName))
+                    .append("%1$-${valueColumnWidth}s".format(valueDecl(value)))
                     .append("   ")
                     .append("%1$-${valueDescColumnWidth}s".format(valueDescription(element, value)))
                     .append("\n")
diff --git a/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java b/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java
index 4ea1536a2f6..b4f0f972387 100644
--- a/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java
@@ -155,6 +155,11 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), true);
         }
         
+        @TestMetadata("bothReceivers.kt")
+        public void testBothReceivers() throws Exception {
+            doTest("compiler/testData/cfg/conventions/bothReceivers.kt");
+        }
+        
         @TestMetadata("equals.kt")
         public void testEquals() throws Exception {
             doTest("compiler/testData/cfg/conventions/equals.kt");
diff --git a/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java b/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java
index 326aedc5a82..f530d7e7c02 100644
--- a/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java
@@ -157,6 +157,11 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest {
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), true);
             }
             
+            @TestMetadata("bothReceivers.kt")
+            public void testBothReceivers() throws Exception {
+                doTest("compiler/testData/cfg/conventions/bothReceivers.kt");
+            }
+            
             @TestMetadata("equals.kt")
             public void testEquals() throws Exception {
                 doTest("compiler/testData/cfg/conventions/equals.kt");
diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
index 7c29790768c..578d071ffed 100644
--- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
@@ -17,10 +17,13 @@
 package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.base.Predicate;
-import com.google.common.collect.*;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import com.intellij.util.containers.ContainerUtil;
 import kotlin.Function1;
 import kotlin.Unit;
+import kotlin.jvm.KotlinSignature;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -31,12 +34,11 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
+import org.jetbrains.jet.utils.DFS;
 
 import java.util.*;
 
-import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.CONFLICT;
-import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.INCOMPATIBLE;
-import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
+import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.*;
 
 public class OverridingUtil {
 
@@ -512,6 +514,32 @@ public class OverridingUtil {
         return maxVisibility;
     }
 
+
+    @NotNull
+    @KotlinSignature("fun getTopmostOverridenDescriptors(originalDescriptor: CallableDescriptor): List<out CallableDescriptor>")
+    public static List<? extends CallableDescriptor> getTopmostOverridenDescriptors(@NotNull CallableDescriptor originalDescriptor) {
+        return DFS.dfs(
+                Collections.singletonList(originalDescriptor),
+                new DFS.Neighbors<CallableDescriptor>() {
+                    @NotNull
+                    @Override
+                    public Iterable<? extends CallableDescriptor> getNeighbors(CallableDescriptor current) {
+                        return current.getOverriddenDescriptors();
+                    }
+                },
+                new DFS.CollectingNodeHandler<CallableDescriptor, CallableDescriptor, ArrayList<CallableDescriptor>>(
+                        new ArrayList<CallableDescriptor>()
+                ) {
+                    @Override
+                    public void afterChildren(CallableDescriptor current) {
+                        if (current.getOverriddenDescriptors().isEmpty()) {
+                            result.add(current);
+                        }
+                    }
+                }
+        );
+    }
+
     public interface DescriptorSink {
         void addToScope(@NotNull CallableMemberDescriptor fakeOverride);
 
diff --git a/core/util.runtime/src/org/jetbrains/jet/utils/DFS.java b/core/util.runtime/src/org/jetbrains/jet/utils/DFS.java
index 648b0215d5c..ca9103af9ff 100644
--- a/core/util.runtime/src/org/jetbrains/jet/utils/DFS.java
+++ b/core/util.runtime/src/org/jetbrains/jet/utils/DFS.java
@@ -91,7 +91,7 @@ public class DFS {
     public interface Neighbors<N> {
         @KotlinSignature("fun getNeighbors(current: N): Iterable<N>")
         @NotNull
-        Iterable<N> getNeighbors(N current);
+        Iterable<? extends N> getNeighbors(N current);
     }
 
     public interface Visited<N> {