diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt
index 8303a67aa6..27bf8692e1 100644
--- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt
+++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt
@@ -480,6 +480,11 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
      */
     var useBytecodeTransformation by getBooleanProperty(false)
 
+    /**
+     * Type of trace instrumentation.
+     */
+    var traceInstrumentationType by getEnumProperty(TraceInstrumentationType.INSTRUCTION)
+
     /**
      * Limit for number of generated tests per method (in each region)
      */
@@ -756,3 +761,16 @@ enum class ExploreThrowableDepth {
      */
     EXPLORE_ALL_STATEMENTS
 }
+
+enum class TraceInstrumentationType {
+
+    /**
+     * Insert probes before each bytecode instruction.
+     */
+    INSTRUCTION,
+
+    /**
+     * Insert probes into the [control flow graph](https://www.eclemma.org/jacoco/trunk/doc/flow.html).
+     */
+    BRANCH
+}
\ No newline at end of file
diff --git a/utbot-framework/src/main/kotlin/org/utbot/framework/coverage/CoverageCalculator.kt b/utbot-framework/src/main/kotlin/org/utbot/framework/coverage/CoverageCalculator.kt
index c662da9b31..4bc34a4cc3 100644
--- a/utbot-framework/src/main/kotlin/org/utbot/framework/coverage/CoverageCalculator.kt
+++ b/utbot-framework/src/main/kotlin/org/utbot/framework/coverage/CoverageCalculator.kt
@@ -1,19 +1,19 @@
 package org.utbot.framework.coverage
 
+import kotlinx.coroutines.runBlocking
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.UtValueExecution
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.instrumentation.coverage.CoverageInfo
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.util.StaticEnvironment
-import kotlinx.coroutines.runBlocking
 
 fun methodCoverage(executable: ExecutableId, executions: List<UtValueExecution<*>>, classpath: String): Coverage {
     val methodSignature = executable.signature
     val classId = executable.classId
-    return ConcreteExecutor(CoverageInstrumentation.Factory, classpath).let { executor ->
+    return ConcreteExecutor(InstructionCoverageInstrumentation.Factory, classpath).let { executor ->
         for (execution in executions) {
             val args = execution.stateBefore.params.map { it.value }.toMutableList()
             val caller = execution.stateBefore.caller
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestBranchCoverageInstrumentation.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestBranchCoverageInstrumentation.kt
new file mode 100644
index 0000000000..03b5602f4b
--- /dev/null
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestBranchCoverageInstrumentation.kt
@@ -0,0 +1,93 @@
+package org.utbot.examples
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.utbot.examples.samples.ExampleClass
+import org.utbot.examples.samples.et.ClassSimpleCatch
+import org.utbot.examples.statics.substitution.StaticSubstitution
+import org.utbot.examples.statics.substitution.StaticSubstitutionExamples
+import org.utbot.framework.plugin.api.util.fieldId
+import org.utbot.framework.plugin.api.util.signature
+import org.utbot.instrumentation.execute
+import org.utbot.instrumentation.instrumentation.coverage.BranchCoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
+import org.utbot.instrumentation.util.StaticEnvironment
+import org.utbot.instrumentation.withInstrumentation
+
+class TestBranchCoverageInstrumentation {
+    lateinit var utContext: AutoCloseable
+
+    @Test
+    fun testIfBranches() {
+        withInstrumentation(
+            BranchCoverageInstrumentation.Factory,
+            ExampleClass::class.java.protectionDomain.codeSource.location.path
+        ) { executor ->
+            val testObject = ExampleClass()
+
+            executor.execute(ExampleClass::bar, arrayOf(testObject, 2))
+            val coverageInfo1 = executor.collectCoverage(ExampleClass::class.java)
+
+            assertEquals(2, coverageInfo1.visitedInstrs.size)
+            assertEquals(1..3, coverageInfo1.methodToInstrRange[ExampleClass::bar.signature])
+
+            executor.execute(ExampleClass::bar, arrayOf(testObject, 0))
+            val coverageInfo2 = executor.collectCoverage(ExampleClass::class.java)
+
+            assertEquals(2, coverageInfo2.visitedInstrs.size)
+            assertEquals(1..3, coverageInfo2.methodToInstrRange[ExampleClass::bar.signature])
+        }
+    }
+
+    @Test
+    fun testTryCatch() {
+        withInstrumentation(
+            BranchCoverageInstrumentation.Factory,
+            ClassSimpleCatch::class.java.protectionDomain.codeSource.location.path
+        ) { executor ->
+            executor.execute(ClassSimpleCatch::A_catches, emptyArray())
+            val coverageInfo1 = executor.collectCoverage(ClassSimpleCatch::class.java)
+
+            assertEquals(2, coverageInfo1.visitedInstrs.size)
+            assertEquals(3..5, coverageInfo1.methodToInstrRange[ClassSimpleCatch::A_catches.signature])
+
+            executor.execute(ClassSimpleCatch::A_catchesWrongException, emptyArray())
+            val coverageInfo2 = executor.collectCoverage(ClassSimpleCatch::class.java)
+
+            assertEquals(0, coverageInfo2.visitedInstrs.size)
+            assertEquals(7..9, coverageInfo2.methodToInstrRange[ClassSimpleCatch::A_catchesWrongException.signature])
+        }
+    }
+
+    @Test
+    fun testTernaryOperator() {
+        withInstrumentation(
+            BranchCoverageInstrumentation.Factory,
+            StaticSubstitutionExamples::class.java.protectionDomain.codeSource.location.path
+        ) { executor ->
+            val testObject = StaticSubstitutionExamples()
+
+            val emptyStaticEnvironment = StaticEnvironment()
+
+            val res1 = executor.execute(
+                StaticSubstitutionExamples::lessThanZero,
+                arrayOf(testObject),
+                parameters = emptyStaticEnvironment
+            )
+
+            val staticEnvironment = StaticEnvironment(
+                StaticSubstitution::mutableValue.fieldId to -1
+            )
+            val res2 = executor.execute(
+                StaticSubstitutionExamples::lessThanZero,
+                arrayOf(testObject),
+                parameters = staticEnvironment
+            )
+            val coverageInfo = executor.collectCoverage(StaticSubstitutionExamples::class.java)
+
+            assertEquals(res1.getOrNull(), 5)
+            assertEquals(res2.getOrNull(), 0)
+            assertEquals(coverageInfo.visitedInstrs, (1..3).toList())
+        }
+    }
+}
\ No newline at end of file
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestConstructors.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestConstructors.kt
index fea5acdb17..fecbe02f8f 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestConstructors.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestConstructors.kt
@@ -6,7 +6,7 @@ import org.utbot.framework.plugin.api.util.signature
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.execute
 import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.instrumentation.et.ExecutionTraceInstrumentation
 import org.utbot.instrumentation.instrumentation.et.convert
@@ -86,7 +86,7 @@ class TestConstructors {
     @Test
     fun testCoverageConstructor() {
         withInstrumentation(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             CLASSPATH
         ) { executor ->
             val constructors = ClassWithMultipleConstructors::class.constructors
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestCoverageInstrumentation.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestInstructionCoverageInstrumentation.kt
similarity index 92%
rename from utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestCoverageInstrumentation.kt
rename to utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestInstructionCoverageInstrumentation.kt
index 565ca75f12..47a8f70475 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestCoverageInstrumentation.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestInstructionCoverageInstrumentation.kt
@@ -8,7 +8,7 @@ import org.utbot.framework.plugin.api.util.fieldId
 import org.utbot.framework.plugin.api.util.signature
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.execute
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.util.InstrumentedProcessError
 import org.utbot.instrumentation.util.StaticEnvironment
@@ -18,13 +18,13 @@ import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
-class TestCoverageInstrumentation {
+class TestInstructionCoverageInstrumentation {
     lateinit var utContext: AutoCloseable
 
     @Test
     fun testCatchTargetException() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -41,7 +41,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testIfBranches() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -63,7 +63,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testWrongArgumentsException() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -86,7 +86,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testMultipleRunsInsideCoverage() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -121,7 +121,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testSameResult() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -143,7 +143,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testResult() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -160,7 +160,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testEmptyMethod() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = ExampleClass()
@@ -176,7 +176,7 @@ class TestCoverageInstrumentation {
     @Test
     fun testTernaryOperator() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             StaticSubstitutionExamples::class.java.protectionDomain.codeSource.location.path
         ).use {
             val testObject = StaticSubstitutionExamples()
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestStaticMethods.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestStaticMethods.kt
index 0a75292636..b60ea80260 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestStaticMethods.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestStaticMethods.kt
@@ -4,7 +4,7 @@ import org.utbot.examples.samples.staticenvironment.StaticExampleClass
 import org.utbot.framework.plugin.api.util.signature
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.execute
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
@@ -17,7 +17,7 @@ class TestStaticMethods {
     @Test
     fun testStaticMethodCall() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             StaticExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val res1 = it.execute(StaticExampleClass::inc, arrayOf())
@@ -44,7 +44,7 @@ class TestStaticMethods {
     @Test
     fun testNullableMethod() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             StaticExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val res1 = it.execute(
@@ -75,7 +75,7 @@ class TestStaticMethods {
     @Test
     fun testNullableMethodWithoutAnnotations() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             StaticExampleClass::class.java.protectionDomain.codeSource.location.path
         ).use {
             val res1 = it.execute(
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestWithInstrumentation.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestWithInstrumentation.kt
index ae00e0f7a8..dbb95e5df1 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestWithInstrumentation.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/TestWithInstrumentation.kt
@@ -6,7 +6,7 @@ import org.utbot.examples.samples.staticenvironment.StaticExampleClass
 import org.utbot.framework.plugin.api.util.signature
 import org.utbot.instrumentation.execute
 import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.withInstrumentation
 import kotlin.reflect.full.declaredMembers
@@ -20,7 +20,7 @@ class TestWithInstrumentation {
     @Test
     fun testStaticMethodCall() {
         withInstrumentation(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             StaticExampleClass::class.java.protectionDomain.codeSource.location.path
         ) { executor ->
             val res1 = executor.execute(StaticExampleClass::inc, arrayOf())
@@ -70,7 +70,7 @@ class TestWithInstrumentation {
     @Test
     fun testInnerClasses() {
         withInstrumentation(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             ClassWithInnerClasses::class.java.protectionDomain.codeSource.location.path
         ) { executor ->
             val innerClazz = ClassWithInnerClasses.InnerClass::class.java
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/Benchmark.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/Benchmark.kt
index d4e9ba2028..43ec154e52 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/Benchmark.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/Benchmark.kt
@@ -2,7 +2,7 @@ package org.utbot.examples.benchmark
 
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.util.Isolated
 import kotlin.system.measureNanoTime
@@ -12,7 +12,7 @@ import org.junit.jupiter.api.Assertions.assertEquals
 fun getBasicCoverageTime(count: Int): Double {
     var time: Long
     ConcreteExecutor(
-        CoverageInstrumentation.Factory,
+        InstructionCoverageInstrumentation.Factory,
         Repeater::class.java.protectionDomain.codeSource.location.path
     ).use { executor ->
         val dc0 = Repeater(", ")
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/BenchmarkFibonacci.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/BenchmarkFibonacci.kt
index 07d788e4ce..88b3205ca2 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/BenchmarkFibonacci.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/BenchmarkFibonacci.kt
@@ -5,7 +5,7 @@ import org.utbot.framework.plugin.api.util.UtContext
 import org.utbot.framework.plugin.api.util.withUtContext
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.util.Isolated
 import kotlin.system.measureNanoTime
@@ -13,7 +13,7 @@ import kotlin.system.measureNanoTime
 fun getBasicCoverageTime_fib(count: Int): Double {
     var time: Long
     ConcreteExecutor(
-        CoverageInstrumentation.Factory,
+        InstructionCoverageInstrumentation.Factory,
         Fibonacci::class.java.protectionDomain.codeSource.location.path
     ).use {
         val fib = Isolated(Fibonacci::calc, it)
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/TestBenchmarkClasses.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/TestBenchmarkClasses.kt
index f189907c5d..31d0556f02 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/TestBenchmarkClasses.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/TestBenchmarkClasses.kt
@@ -4,7 +4,7 @@ import org.utbot.examples.samples.benchmark.Fibonacci
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.execute
 import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import java.math.BigInteger
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Disabled
@@ -18,7 +18,7 @@ class TestBenchmarkClasses {
     @Disabled("Ask Sergey to check")
     fun testRepeater() {
         ConcreteExecutor(
-            CoverageInstrumentation.Factory,
+            InstructionCoverageInstrumentation.Factory,
             Repeater::class.java.protectionDomain.codeSource.location.path
         ).use {
             val dc0 = Repeater(", ")
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/et/TestExecutionBranchTraceInstrumentation.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/et/TestExecutionBranchTraceInstrumentation.kt
new file mode 100644
index 0000000000..923e21fa1d
--- /dev/null
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/et/TestExecutionBranchTraceInstrumentation.kt
@@ -0,0 +1,127 @@
+package org.utbot.examples.et
+
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+import org.utbot.examples.samples.et.ClassSimple
+import org.utbot.examples.samples.et.ClassSimpleCatch
+import org.utbot.instrumentation.instrumentation.et.*
+import org.utbot.instrumentation.util.Isolated
+import org.utbot.instrumentation.withInstrumentation
+
+class TestExecutionBranchTraceInstrumentation {
+    lateinit var utContext: AutoCloseable
+
+    val CLASSPATH = ClassSimple::class.java.protectionDomain.codeSource.location.path
+
+    @Test
+    fun testClassSimple() {
+        withInstrumentation(
+            ExecutionBranchTraceInstrumentation.Factory,
+            CLASSPATH
+        ) { executor ->
+            val doesNotThrow = Isolated(ClassSimple::doesNotThrow, executor)
+            val alwaysThrows = Isolated(ClassSimple::alwaysThrows, executor)
+            val maybeThrows = Isolated(ClassSimple::maybeThrows, executor)
+
+            val et1 = doesNotThrow()
+            Assertions.assertEquals(
+                function(doesNotThrow.signature) {
+                    pass()
+                    ret()
+                },
+                convert(et1)
+            )
+
+            val et2 = alwaysThrows()
+            Assertions.assertEquals(
+                function(alwaysThrows.signature) {
+                    pass()
+                    explThr()
+                },
+                convert(et2)
+            )
+
+            val et3 = maybeThrows(-1)
+            Assertions.assertEquals(
+                function(maybeThrows.signature) {
+                    pass()
+                    explThr()
+                },
+                convert(et3)
+            )
+
+            val et4 = maybeThrows(0)
+            Assertions.assertEquals(
+                function(maybeThrows.signature) {
+                    pass()
+                    ret()
+                },
+                convert(et4)
+            )
+        }
+    }
+
+    @Test
+    fun testClasSimpleCatch() {
+        withInstrumentation(
+            ExecutionBranchTraceInstrumentation.Factory,
+            CLASSPATH
+        ) { executor ->
+            val A = Isolated(ClassSimpleCatch::A, executor)
+            val A_catches = Isolated(ClassSimpleCatch::A_catches, executor)
+            val A_catchesWrongException = Isolated(ClassSimpleCatch::A_catchesWrongException, executor)
+            val A_doesNotCatch = Isolated(ClassSimpleCatch::A_doesNotCatch, executor)
+
+            val B = Isolated(ClassSimpleCatch::B, executor)
+            val B_throws = Isolated(ClassSimpleCatch::B_throws, executor)
+
+            val et1 = A()
+            Assertions.assertEquals(
+                function(A.signature) {
+                    pass()
+                    invoke(B.signature) {
+                        pass()
+                        ret()
+                    }
+                    ret()
+                },
+                convert(et1)
+            )
+
+            val et2 = A_catches()
+            Assertions.assertEquals(
+                function(A_catches.signature) {
+                    pass()
+                    invoke(B_throws.signature) {
+                        implThr()
+                    }
+                    pass()
+                    ret()
+                },
+                convert(et2)
+            )
+
+            val et3 = A_catchesWrongException()
+            Assertions.assertEquals(
+                function(A_catchesWrongException.signature) {
+                    pass()
+                    invoke(B_throws.signature) {
+                        implThr()
+                    }
+                },
+                convert(et3)
+            )
+
+            val et4 = A_doesNotCatch()
+            Assertions.assertEquals(
+                function(A_doesNotCatch.signature) {
+                    pass()
+                    invoke(B_throws.signature) {
+                        implThr()
+                    }
+                },
+                convert(et4)
+            )
+        }
+    }
+}
diff --git a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/jacoco/TestSameAsJaCoCo.kt b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/jacoco/TestSameAsJaCoCo.kt
index a289e1d5fa..5c946c0e3a 100644
--- a/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/jacoco/TestSameAsJaCoCo.kt
+++ b/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/jacoco/TestSameAsJaCoCo.kt
@@ -8,7 +8,7 @@ import org.utbot.framework.plugin.api.util.signature
 import org.utbot.instrumentation.execute
 import org.utbot.instrumentation.instrumentation.ArgumentList
 import org.utbot.instrumentation.instrumentation.coverage.CoverageInfo
-import org.utbot.instrumentation.instrumentation.coverage.CoverageInstrumentation
+import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
 import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
 import org.utbot.instrumentation.withInstrumentation
 import java.io.InputStream
@@ -123,7 +123,7 @@ private fun methodCoverageWithJaCoCo(kClass: KClass<*>, method: KCallable<*>, ex
 
 private fun methodCoverage(kClass: KClass<*>, method: KCallable<*>, executions: List<ArgumentList>): Pair<Int, Int> {
     return withInstrumentation(
-        CoverageInstrumentation.Factory,
+        InstructionCoverageInstrumentation.Factory,
         kClass.java.protectionDomain.codeSource.location.path
     ) { executor ->
         for (execution in executions) {
diff --git a/utbot-instrumentation/build.gradle.kts b/utbot-instrumentation/build.gradle.kts
index ca8ea1f469..172aaf4f9f 100644
--- a/utbot-instrumentation/build.gradle.kts
+++ b/utbot-instrumentation/build.gradle.kts
@@ -8,6 +8,8 @@ val rdVersion: String by rootProject
 val mockitoVersion: String by rootProject
 val mockitoInlineVersion: String by rootProject
 
+val jacocoVersion: String by rootProject
+
 plugins {
     id("com.github.johnrengelman.shadow") version "7.1.2"
     id("java")
@@ -56,6 +58,8 @@ dependencies {
     implementation("org.mockito:mockito-core:$mockitoVersion")
     implementation("org.mockito:mockito-inline:$mockitoInlineVersion")
 
+    implementation("org.jacoco:org.jacoco.core:$jacocoVersion")
+
     implementation(project(":utbot-spring-commons-api"))
     fetchSpringCommonsJar(project(":utbot-spring-commons", configuration = "springCommonsJar"))
 }
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/Api.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/Api.kt
new file mode 100644
index 0000000000..e8ba862153
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/Api.kt
@@ -0,0 +1,62 @@
+package org.jacoco.core.internal.instr
+
+import org.jacoco.core.internal.flow.ClassProbesAdapter
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.ClassWriter
+import org.utbot.instrumentation.Settings
+import org.utbot.instrumentation.instrumentation.et.ProcessingStorage
+
+fun createClassVisitorForBranchCoverageInstrumentation(
+    writer: ClassWriter,
+    className: String
+): ClassProbesAdapter {
+    val strategy = ProbeArrayStrategy(className)
+    return ClassProbesAdapter(
+        ClassInstrumenter(strategy, writer),
+        false
+    )
+}
+
+class MethodProbesCollector(
+    strategy: IProbeArrayStrategy,
+    writer: ClassVisitor,
+    val methodToProbes: MutableMap<String, MutableList<Int>> = mutableMapOf()
+) : ClassVisitor(
+    Settings.ASM_API,
+    ClassProbesAdapter(
+        NoneClassInstrumenter(strategy, writer, methodToProbes),
+        false
+    )
+)
+
+fun createClassVisitorForComputeMapOfRangesForBranchCoverage(
+    writer: ClassWriter
+): MethodProbesCollector {
+    val strategy = NoneProbeArrayStrategy()
+    return MethodProbesCollector(strategy, writer)
+}
+
+class ProbeIdGenerator(private val f: (Int) -> Long) {
+
+    private var localId: Int = 0
+
+    fun currentId(): Long = f(localId)
+
+    fun nextId(): Long = f(localId++)
+
+}
+
+fun createClassVisitorForTracingBranchInstructions(
+    className: String,
+    storage: ProcessingStorage,
+    writer: ClassWriter
+): ClassProbesAdapter {
+    val strategy = TraceStrategy()
+    val probeIdGenerator = ProbeIdGenerator { localId ->
+        storage.computeId(className, localId)
+    }
+    return ClassProbesAdapter(
+        TraceClassInstrumenter(strategy, writer, className, storage, probeIdGenerator),
+        false
+    )
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneClassInstrumenter.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneClassInstrumenter.kt
new file mode 100644
index 0000000000..6fada8d8b2
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneClassInstrumenter.kt
@@ -0,0 +1,30 @@
+package org.jacoco.core.internal.instr
+
+import org.jacoco.core.internal.flow.MethodProbesVisitor
+import org.objectweb.asm.ClassVisitor
+
+/**
+ * Just a copy of [ClassInstrumenter] with one overridden method.
+ * This class is used to replace probe inserter.
+ */
+class NoneClassInstrumenter(
+    probeArrayStrategy: IProbeArrayStrategy,
+    cv: ClassVisitor,
+    private val methodToProbes: MutableMap<String, MutableList<Int>>,
+) : ClassInstrumenter(probeArrayStrategy, cv) {
+
+    override fun visitMethod(
+        access: Int,
+        name: String,
+        desc: String,
+        signature: String?,
+        exceptions: Array<out String>?
+    ): MethodProbesVisitor {
+        val mv = cv.visitMethod(access, name, desc, signature, exceptions)
+
+        val frameEliminator = DuplicateFrameEliminator(mv)
+        val probeVariableInserter = NoneProbeInserter(name, desc, methodToProbes, frameEliminator)
+        return MethodInstrumenter(probeVariableInserter, probeVariableInserter)
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneProbeInserter.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneProbeInserter.kt
new file mode 100644
index 0000000000..cabce1c099
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/NoneProbeInserter.kt
@@ -0,0 +1,22 @@
+package org.jacoco.core.internal.instr
+
+import org.objectweb.asm.MethodVisitor
+import org.utbot.instrumentation.Settings
+
+/**
+ * This inserter does not emit any code at all. This is used to collect method probes.
+ */
+class NoneProbeInserter(
+    methodName: String,
+    descriptor: String,
+    private val methodToProbes: MutableMap<String, MutableList<Int>>,
+    mv: MethodVisitor,
+) : IProbeInserter, MethodVisitor(Settings.ASM_API, mv) {
+
+    private val currentMethodSignature: String = methodName + descriptor
+
+    override fun insertProbe(id: Int) {
+        methodToProbes.getOrPut(currentMethodSignature) { mutableListOf() }.add(id)
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/ProbeArrayStrategy.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/ProbeArrayStrategy.kt
new file mode 100644
index 0000000000..1057b4302f
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/ProbeArrayStrategy.kt
@@ -0,0 +1,20 @@
+package org.jacoco.core.internal.instr
+
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.utbot.instrumentation.Settings
+
+class ProbeArrayStrategy(private val className: String) : IProbeArrayStrategy {
+
+    override fun storeInstance(mv: MethodVisitor, clinit: Boolean, variable: Int): Int {
+        mv.visitFieldInsn(Opcodes.GETSTATIC, className, Settings.PROBES_ARRAY_NAME, Settings.PROBES_ARRAY_DESC)
+        mv.visitVarInsn(Opcodes.ASTORE, variable)
+        return 1
+    }
+
+    override fun addMembers(cv: ClassVisitor, probeCount: Int) {
+        // nothing to do
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceClassInstrumenter.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceClassInstrumenter.kt
new file mode 100644
index 0000000000..f996ff8f59
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceClassInstrumenter.kt
@@ -0,0 +1,40 @@
+package org.jacoco.core.internal.instr
+
+import org.jacoco.core.internal.flow.MethodProbesVisitor
+import org.objectweb.asm.ClassVisitor
+import org.utbot.instrumentation.instrumentation.et.ProcessingStorage
+
+/**
+ * Just a copy of [ClassInstrumenter] with one overridden method.
+ * This class is used to replace probe inserter and method instrumenter.
+ */
+class TraceClassInstrumenter(
+    private val probeArrayStrategy: IProbeArrayStrategy,
+    cv: ClassVisitor,
+    private val className: String,
+    private val storage: ProcessingStorage,
+    private val probeIdGenerator: ProbeIdGenerator
+) : ClassInstrumenter(probeArrayStrategy, cv) {
+
+    override fun visitMethod(
+        access: Int,
+        name: String,
+        desc: String,
+        signature: String?,
+        exceptions: Array<out String>?
+    ): MethodProbesVisitor {
+        val mv = cv.visitMethod(access, name, desc, signature, exceptions)
+
+        val currentMethodSignature = name + desc
+        storage.addClassMethod(className, currentMethodSignature)
+
+        val frameEliminator = DuplicateFrameEliminator(mv)
+        val probeVariableInserter = TraceProbeInserter(
+            access, name, desc, frameEliminator, probeArrayStrategy, probeIdGenerator
+        )
+        return TraceMethodInstrumenter(
+            currentMethodSignature, probeVariableInserter, probeVariableInserter, storage, probeIdGenerator
+        )
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceMethodInstrumenter.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceMethodInstrumenter.kt
new file mode 100644
index 0000000000..80f9b83fd9
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceMethodInstrumenter.kt
@@ -0,0 +1,155 @@
+package org.jacoco.core.internal.instr
+
+import org.jacoco.core.internal.flow.IFrame
+import org.jacoco.core.internal.flow.LabelInfo
+import org.objectweb.asm.Label
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.utbot.instrumentation.instrumentation.et.*
+import org.utbot.instrumentation.instrumentation.instrumenter.visitors.util.InstructionVisitorMethodAdapter.Companion.returnInsns
+
+internal class TraceMethodInstrumenter(
+    private val currentMethodSignature: String,
+    mv: MethodVisitor,
+    private val probeInserter: IProbeInserter,
+    private val storage: ProcessingStorage,
+    private val probeIdGenerator: ProbeIdGenerator
+) : MethodInstrumenter(mv, probeInserter) {
+
+    private var currentLineNumber: Int = 0
+
+    // === MethodVisitor ===
+
+    override fun visitCode() {
+        storeInstruction(CommonInstruction(currentLineNumber, currentMethodSignature))
+        super.visitCode()
+    }
+
+    override fun visitMethodInsn(
+        opcode: Int,
+        owner: String?,
+        name: String?,
+        descriptor: String?,
+        isInterface: Boolean
+    ) {
+        storeInstruction(InvokeInstruction(currentLineNumber, currentMethodSignature))
+        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
+    }
+
+    override fun visitLineNumber(line: Int, start: Label?) {
+        currentLineNumber = line
+        super.visitLineNumber(line, start)
+    }
+
+    // === MethodInstrumenter ===
+
+    private fun storeInstruction(instructionData: InstructionData) {
+        val id = probeIdGenerator.currentId()
+        storage.addInstruction(id, instructionData)
+    }
+
+    override fun visitProbe(localId: Int) {
+        storeInstruction(CommonInstruction(currentLineNumber, currentMethodSignature))
+        super.visitProbe(localId)
+    }
+
+    override fun visitInsnWithProbe(opcode: Int, localId: Int) {
+        when (opcode) {
+            in returnInsns -> {
+                storeInstruction(ReturnInstruction(currentLineNumber, currentMethodSignature))
+            }
+
+            Opcodes.ATHROW -> {
+                storeInstruction(ExplicitThrowInstruction(currentLineNumber, currentMethodSignature))
+            }
+        }
+        super.visitInsnWithProbe(opcode, localId)
+    }
+
+    override fun visitJumpInsnWithProbe(opcode: Int, label: Label?, localId: Int, frame: IFrame?) {
+        storeInstruction(CommonInstruction(currentLineNumber, currentMethodSignature))
+        super.visitJumpInsnWithProbe(opcode, label, localId, frame)
+    }
+
+    override fun visitTableSwitchInsnWithProbes(
+        min: Int, max: Int,
+        dflt: Label, labels: Array<Label>, frame: IFrame
+    ) {
+        // 1. Calculate intermediate labels:
+        LabelInfo.resetDone(dflt)
+        LabelInfo.resetDone(labels)
+        val newDflt = createIntermediate(dflt)
+        val newLabels = createIntermediates(labels)
+        mv.visitTableSwitchInsn(min, max, newDflt, *newLabels)
+
+        // 2. Insert probes:
+        insertIntermediateProbes(dflt, labels, frame)
+    }
+
+    override fun visitLookupSwitchInsnWithProbes(
+        dflt: Label,
+        keys: IntArray?, labels: Array<Label>, frame: IFrame
+    ) {
+        // 1. Calculate intermediate labels:
+        LabelInfo.resetDone(dflt)
+        LabelInfo.resetDone(labels)
+        val newDflt = createIntermediate(dflt)
+        val newLabels = createIntermediates(labels)
+        mv.visitLookupSwitchInsn(newDflt, keys, newLabels)
+
+        // 2. Insert probes:
+        insertIntermediateProbes(dflt, labels, frame)
+    }
+
+    private fun createIntermediates(labels: Array<Label>): Array<Label?> {
+        val intermediates = arrayOfNulls<Label>(labels.size)
+        for (i in labels.indices) {
+            intermediates[i] = createIntermediate(labels[i])
+        }
+        return intermediates
+    }
+
+    private fun createIntermediate(label: Label): Label {
+        val intermediate: Label
+        if (LabelInfo.getProbeId(label) == LabelInfo.NO_PROBE) {
+            intermediate = label
+        } else {
+            if (LabelInfo.isDone(label)) {
+                intermediate = LabelInfo.getIntermediateLabel(label)
+            } else {
+                intermediate = Label()
+                LabelInfo.setIntermediateLabel(label, intermediate)
+                LabelInfo.setDone(label)
+            }
+        }
+        return intermediate
+    }
+
+    private fun insertIntermediateProbe(
+        label: Label,
+        frame: IFrame
+    ) {
+        val localId = LabelInfo.getProbeId(label)
+        if (localId != LabelInfo.NO_PROBE && !LabelInfo.isDone(label)) {
+            mv.visitLabel(LabelInfo.getIntermediateLabel(label))
+            frame.accept(mv)
+            storeInstruction(CommonInstruction(currentLineNumber, currentMethodSignature))
+            probeInserter.insertProbe(localId)
+            mv.visitJumpInsn(Opcodes.GOTO, label)
+            LabelInfo.setDone(label)
+        }
+    }
+
+    private fun insertIntermediateProbes(
+        dflt: Label,
+        labels: Array<Label>, frame: IFrame
+    ) {
+        LabelInfo.resetDone(dflt)
+        LabelInfo.resetDone(labels)
+        insertIntermediateProbe(dflt, frame)
+        for (l in labels) {
+            insertIntermediateProbe(l, frame)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceProbeInserter.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceProbeInserter.kt
new file mode 100644
index 0000000000..ee5e54aef4
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceProbeInserter.kt
@@ -0,0 +1,53 @@
+package org.jacoco.core.internal.instr
+
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.Type
+import org.utbot.instrumentation.instrumentation.et.RuntimeTraceStorage
+import kotlin.reflect.jvm.javaMethod
+
+internal class TraceProbeInserter(
+    access: Int,
+    name: String,
+    desc: String,
+    mv: MethodVisitor,
+    arrayStrategy: IProbeArrayStrategy,
+    private val probeIdGenerator: ProbeIdGenerator,
+) : ProbeInserter(access, name, desc, mv, arrayStrategy) {
+
+    private val internalName = Type.getInternalName(RuntimeTraceStorage::class.java)
+    private val visitMethodDescriptor = Type.getMethodDescriptor(RuntimeTraceStorage::visit.javaMethod)
+    private val variable: Int
+
+    init {
+        var pos = if (Opcodes.ACC_STATIC and access == 0) 1 else 0
+        for (t in Type.getArgumentTypes(desc)) {
+            pos += t.size
+        }
+        variable = pos
+    }
+
+    override fun insertProbe(ignored: Int) {
+        mv.visitVarInsn(Opcodes.ILOAD, variable)
+        val id = probeIdGenerator.nextId()
+        mv.visitLdcInsn(id)
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC, internalName, "visit", visitMethodDescriptor, false)
+    }
+
+    override fun visitCode() {
+        super.visitCode()
+        insertProbe(0)
+    }
+
+    override fun visitMethodInsn(
+        opcode: Int,
+        owner: String?,
+        name: String?,
+        descriptor: String?,
+        isInterface: Boolean
+    ) {
+        insertProbe(0)
+        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceStrategy.kt b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceStrategy.kt
new file mode 100644
index 0000000000..fe6b2a6937
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/jacoco/core/internal/instr/TraceStrategy.kt
@@ -0,0 +1,30 @@
+package org.jacoco.core.internal.instr
+
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.Type
+import org.utbot.instrumentation.instrumentation.et.RuntimeTraceStorage
+import kotlin.reflect.jvm.javaField
+
+class TraceStrategy : IProbeArrayStrategy {
+
+    private val internalName = Type.getInternalName(RuntimeTraceStorage::class.java)
+    private val counterCallIdName = RuntimeTraceStorage::`$__counter_call_id__`.javaField!!.name
+
+    override fun storeInstance(mv: MethodVisitor, clinit: Boolean, variable: Int): Int {
+        // int variable = RuntimeTraceStorage.$__counter_call_id__++
+        mv.visitFieldInsn(Opcodes.GETSTATIC, internalName, counterCallIdName, RuntimeTraceStorage.DESC_CALL_ID_COUNTER)
+        mv.visitInsn(Opcodes.ICONST_1)
+        mv.visitInsn(Opcodes.IADD)
+        mv.visitInsn(Opcodes.DUP)
+        mv.visitFieldInsn(Opcodes.PUTSTATIC, internalName, counterCallIdName, RuntimeTraceStorage.DESC_CALL_ID_COUNTER)
+        mv.visitVarInsn(Opcodes.ISTORE, variable)
+        return 2
+    }
+
+    override fun addMembers(cv: ClassVisitor?, probeCount: Int) {
+        // nothing to do
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/agent/DynamicClassTransformer.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/agent/DynamicClassTransformer.kt
index e9ba0651ff..f391e3f290 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/agent/DynamicClassTransformer.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/agent/DynamicClassTransformer.kt
@@ -4,6 +4,7 @@ import com.jetbrains.rd.util.error
 import com.jetbrains.rd.util.getLogger
 import com.jetbrains.rd.util.info
 import org.utbot.common.asPathToFile
+import org.utbot.framework.TraceInstrumentationType
 import org.utbot.framework.plugin.api.util.UtContext
 import java.lang.instrument.ClassFileTransformer
 import java.nio.file.Paths
@@ -21,6 +22,8 @@ class DynamicClassTransformer : ClassFileTransformer {
     lateinit var transformer: ClassFileTransformer
 
     var useBytecodeTransformation by Delegates.notNull<Boolean>()
+    lateinit var traceInstrumentationType: TraceInstrumentationType
+
     private val pathsToUserClasses = mutableSetOf<String>()
 
     fun addUserPaths(paths: Iterable<String>) {
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/BranchCoverageInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/BranchCoverageInstrumentation.kt
new file mode 100644
index 0000000000..de4aae7ef3
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/BranchCoverageInstrumentation.kt
@@ -0,0 +1,54 @@
+package org.utbot.instrumentation.instrumentation.coverage
+
+import org.jacoco.core.internal.flow.ClassProbesAdapter
+import org.jacoco.core.internal.instr.createClassVisitorForBranchCoverageInstrumentation
+import org.utbot.common.withAccessibility
+import org.utbot.instrumentation.Settings
+import org.utbot.instrumentation.instrumentation.Instrumentation
+import org.utbot.instrumentation.instrumentation.instrumenter.Instrumenter
+import org.utbot.instrumentation.util.CastProbeCounterException
+import org.utbot.instrumentation.util.NoProbeCounterException
+import java.security.ProtectionDomain
+
+/**
+ * This instrumentation allows collecting branch coverage after several calls.
+ */
+class BranchCoverageInstrumentation : CoverageInstrumentation() {
+
+    override fun <T : Any> computeMapOfRanges(clazz: Class<out T>): Map<String, IntRange> {
+        return Instrumenter(clazz).computeMapOfRangesForBranchCoverage()
+    }
+
+    /**
+     * Transforms bytecode such way that it becomes possible to get a branch coverage by JaCoCo.
+     *
+     * Adds set of instructions which marks the executed instruction as completed. Uses static boolean array for this.
+     */
+    override fun transform(
+        loader: ClassLoader?,
+        className: String,
+        classBeingRedefined: Class<*>?,
+        protectionDomain: ProtectionDomain?,
+        classfileBuffer: ByteArray
+    ): ByteArray {
+        val instrumenter = Instrumenter(classfileBuffer)
+
+        val cv = instrumenter.visitClass { writer ->
+            createClassVisitorForBranchCoverageInstrumentation(writer, className)
+        }
+
+        val probeCounterField = ClassProbesAdapter::class.java.declaredFields.firstOrNull { it.name == "counter" }
+            ?: throw NoProbeCounterException(ClassProbesAdapter::class.java, "counter")
+        val probeCounter = probeCounterField.withAccessibility {
+            this.get(cv) as? Int ?: throw CastProbeCounterException()
+        }
+
+        instrumenter.addStaticField(StaticArrayFieldInitializer(className, Settings.PROBES_ARRAY_NAME, probeCounter))
+
+        return instrumenter.classByteCode
+    }
+
+    object Factory : Instrumentation.Factory<Result<*>, BranchCoverageInstrumentation> {
+        override fun create(): BranchCoverageInstrumentation = BranchCoverageInstrumentation()
+    }
+}
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt
index ab3238a97b..811c01eafd 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/CoverageInstrumentation.kt
@@ -2,27 +2,22 @@ package org.utbot.instrumentation.instrumentation.coverage
 
 import kotlinx.coroutines.runBlocking
 import org.utbot.common.withAccessibility
+import org.utbot.framework.plugin.api.FieldId
 import org.utbot.instrumentation.ConcreteExecutor
 import org.utbot.instrumentation.Settings
 import org.utbot.instrumentation.instrumentation.ArgumentList
 import org.utbot.instrumentation.instrumentation.Instrumentation
 import org.utbot.instrumentation.instrumentation.InvokeWithStaticsInstrumentation
-import org.utbot.instrumentation.instrumentation.instrumenter.Instrumenter
+import org.utbot.instrumentation.process.generated.CollectCoverageParams
 import org.utbot.instrumentation.util.CastProbesArrayException
 import org.utbot.instrumentation.util.NoProbesArrayException
-import java.security.ProtectionDomain
-import org.utbot.framework.plugin.api.FieldId
-import org.utbot.instrumentation.process.generated.CollectCoverageParams
 
 data class CoverageInfo(
     val methodToInstrRange: Map<String, IntRange>,
     val visitedInstrs: List<Int>
 )
 
-/**
- * This instrumentation allows collecting coverage after several calls.
- */
-class CoverageInstrumentation : Instrumentation<Result<*>> {
+abstract class CoverageInstrumentation : Instrumentation<Result<*>> {
     private val invokeWithStatics = InvokeWithStaticsInstrumentation()
 
     /**
@@ -62,7 +57,7 @@ class CoverageInstrumentation : Instrumentation<Result<*>> {
             val visitedLines = visitedLinesField.get(null) as? BooleanArray
                 ?: throw CastProbesArrayException()
 
-            val methodToInstrRange = Instrumenter(clazz).computeMapOfRanges()
+            val methodToInstrRange = computeMapOfRanges(clazz)
 
             val res = CoverageInfo(methodToInstrRange, visitedLines.mapIndexed { idx, b ->
                 if (b) idx else null
@@ -74,30 +69,8 @@ class CoverageInstrumentation : Instrumentation<Result<*>> {
         }
     }
 
-    /**
-     * Transforms bytecode such way that it becomes possible to get a coverage.
-     *
-     * Adds set of instructions which marks the executed instruction as completed. Uses static boolean array for this.
-     */
-    override fun transform(
-        loader: ClassLoader?,
-        className: String,
-        classBeingRedefined: Class<*>?,
-        protectionDomain: ProtectionDomain?,
-        classfileBuffer: ByteArray
-    ): ByteArray {
-        val instrumenter = Instrumenter(classfileBuffer)
-
-        val staticArrayStrategy = StaticArrayStrategy(className, Settings.PROBES_ARRAY_NAME)
-        instrumenter.visitInstructions(staticArrayStrategy)
-        instrumenter.addStaticField(staticArrayStrategy)
-
-        return instrumenter.classByteCode
-    }
+    abstract fun <T : Any> computeMapOfRanges(clazz: Class<out T>): Map<String, IntRange>
 
-    object Factory : Instrumentation.Factory<Result<*>, CoverageInstrumentation> {
-        override fun create(): CoverageInstrumentation = CoverageInstrumentation()
-    }
 }
 
 /**
@@ -107,6 +80,8 @@ fun ConcreteExecutor<Result<*>, CoverageInstrumentation>.collectCoverage(clazz:
     withProcess {
         val clazzByteArray = kryoHelper.writeObject(clazz)
 
-        kryoHelper.readObject(instrumentedProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo)
+        kryoHelper.readObject(
+            instrumentedProcessModel.collectCoverage.startSuspending(lifetime, CollectCoverageParams(clazzByteArray)).coverageInfo
+        )
     }
 }
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/InstructionCoverageInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/InstructionCoverageInstrumentation.kt
new file mode 100644
index 0000000000..e89336a886
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/InstructionCoverageInstrumentation.kt
@@ -0,0 +1,41 @@
+package org.utbot.instrumentation.instrumentation.coverage
+
+import org.utbot.instrumentation.Settings
+import org.utbot.instrumentation.instrumentation.Instrumentation
+import org.utbot.instrumentation.instrumentation.instrumenter.Instrumenter
+import java.security.ProtectionDomain
+
+/**
+ * This instrumentation allows collecting instruction coverage after several calls.
+ */
+open class InstructionCoverageInstrumentation : CoverageInstrumentation() {
+
+    override fun <T : Any> computeMapOfRanges(clazz: Class<out T>): Map<String, IntRange> {
+        return Instrumenter(clazz).computeMapOfRangesForInstructionCoverage()
+    }
+
+    /**
+     * Transforms bytecode such way that it becomes possible to get an instruction coverage.
+     *
+     * Adds set of instructions which marks the executed instruction as completed. Uses static boolean array for this.
+     */
+    override fun transform(
+        loader: ClassLoader?,
+        className: String,
+        classBeingRedefined: Class<*>?,
+        protectionDomain: ProtectionDomain?,
+        classfileBuffer: ByteArray
+    ): ByteArray {
+        val instrumenter = Instrumenter(classfileBuffer)
+
+        val staticArrayStrategy = StaticArrayStrategy(className, Settings.PROBES_ARRAY_NAME)
+        instrumenter.visitInstructions(staticArrayStrategy)
+        instrumenter.addStaticField(staticArrayStrategy)
+
+        return instrumenter.classByteCode
+    }
+
+    object Factory : Instrumentation.Factory<Result<*>, InstructionCoverageInstrumentation> {
+        override fun create(): InstructionCoverageInstrumentation = InstructionCoverageInstrumentation()
+    }
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/StaticArrayFieldInitializer.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/StaticArrayFieldInitializer.kt
new file mode 100644
index 0000000000..cc4f9411ab
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/coverage/StaticArrayFieldInitializer.kt
@@ -0,0 +1,24 @@
+package org.utbot.instrumentation.instrumentation.coverage
+
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.utbot.instrumentation.Settings
+import org.utbot.instrumentation.instrumentation.instrumenter.visitors.util.StaticFieldInitializer
+
+class StaticArrayFieldInitializer(
+    private val className: String,
+    override val name: String,
+    private val probesCount: Int
+) : StaticFieldInitializer {
+
+    override val descriptor: String = Settings.PROBES_ARRAY_DESC
+    override val signature: String? = null
+
+    override fun initField(mv: MethodVisitor): MethodVisitor {
+        mv.visitLdcInsn(probesCount)
+        mv.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_BOOLEAN)
+        mv.visitFieldInsn(Opcodes.PUTSTATIC, className, name, Settings.PROBES_ARRAY_DESC)
+        return mv
+    }
+
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionBranchTraceInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionBranchTraceInstrumentation.kt
new file mode 100644
index 0000000000..8797eaee02
--- /dev/null
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionBranchTraceInstrumentation.kt
@@ -0,0 +1,30 @@
+package org.utbot.instrumentation.instrumentation.et
+
+import org.jacoco.core.internal.instr.createClassVisitorForTracingBranchInstructions
+import org.utbot.instrumentation.instrumentation.Instrumentation
+import org.utbot.instrumentation.instrumentation.instrumenter.Instrumenter
+import java.security.ProtectionDomain
+
+class ExecutionBranchTraceInstrumentation : ExecutionTraceInstrumentation() {
+
+    override fun transform(
+        loader: ClassLoader?,
+        className: String,
+        classBeingRedefined: Class<*>?,
+        protectionDomain: ProtectionDomain?,
+        classfileBuffer: ByteArray
+    ): ByteArray {
+        val instrumenter = Instrumenter(classfileBuffer)
+
+        traceHandler.registerClass(className)
+        instrumenter.visitClass { writer ->
+            createClassVisitorForTracingBranchInstructions(className, traceHandler.processingStorage, writer)
+        }
+
+        return instrumenter.classByteCode
+    }
+
+    object Factory : Instrumentation.Factory<Trace, ExecutionBranchTraceInstrumentation> {
+        override fun create(): ExecutionBranchTraceInstrumentation = ExecutionBranchTraceInstrumentation()
+    }
+}
\ No newline at end of file
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionTraceInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionTraceInstrumentation.kt
index f62eff9b47..2b139496e6 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionTraceInstrumentation.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/et/ExecutionTraceInstrumentation.kt
@@ -1,19 +1,19 @@
 package org.utbot.instrumentation.instrumentation.et
 
+import org.utbot.framework.plugin.api.FieldId
 import org.utbot.instrumentation.instrumentation.ArgumentList
 import org.utbot.instrumentation.instrumentation.Instrumentation
 import org.utbot.instrumentation.instrumentation.InvokeWithStaticsInstrumentation
 import org.utbot.instrumentation.instrumentation.instrumenter.Instrumenter
 import java.security.ProtectionDomain
-import org.utbot.framework.plugin.api.FieldId
 
 /**
  * This instrumentation allows to get execution trace during each call.
  */
 
-class ExecutionTraceInstrumentation : Instrumentation<Trace> {
+open class ExecutionTraceInstrumentation : Instrumentation<Trace> {
     private val invokeWithStatics = InvokeWithStaticsInstrumentation()
-    private val traceHandler = TraceHandler()
+    protected val traceHandler = TraceHandler()
 
     /**
      * Invokes a method with the given [methodSignature], the declaring class of which is [clazz], with the supplied
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SimpleUtExecutionInstrumentation.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SimpleUtExecutionInstrumentation.kt
index bfbdabb159..5ccea67aad 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SimpleUtExecutionInstrumentation.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/execution/SimpleUtExecutionInstrumentation.kt
@@ -1,5 +1,7 @@
 package org.utbot.instrumentation.instrumentation.execution
 
+import org.jacoco.core.internal.instr.createClassVisitorForTracingBranchInstructions
+import org.utbot.framework.TraceInstrumentationType
 import org.utbot.framework.plugin.api.EnvironmentModels
 import org.utbot.framework.plugin.api.FieldId
 import org.utbot.framework.plugin.api.MethodId
@@ -163,7 +165,15 @@ class SimpleUtExecutionInstrumentation(
         }
 
         traceHandler.registerClass(className)
-        instrumenter.visitInstructions(traceHandler.computeInstructionVisitor(className))
+        when (Agent.dynamicClassTransformer.traceInstrumentationType) {
+            TraceInstrumentationType.INSTRUCTION -> instrumenter.visitInstructions(
+                traceHandler.computeInstructionVisitor(className)
+            )
+
+            TraceInstrumentationType.BRANCH -> instrumenter.visitClass { writer ->
+                createClassVisitorForTracingBranchInstructions(className, traceHandler.processingStorage, writer)
+            }
+        }
 
         instrumenter.visitClass { writer ->
             NonDeterministicClassVisitor(writer, ndDetector)
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/Instrumenter.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/Instrumenter.kt
index dfb403e0ac..43831435c2 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/Instrumenter.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/Instrumenter.kt
@@ -1,5 +1,6 @@
 package org.utbot.instrumentation.instrumentation.instrumenter
 
+import org.jacoco.core.internal.instr.*
 import org.objectweb.asm.ClassReader
 import org.objectweb.asm.ClassVisitor
 import org.objectweb.asm.ClassWriter
@@ -35,7 +36,7 @@ class Instrumenter(classByteCode: ByteArray, val classLoader: ClassLoader? = nul
         return classVisitor
     }
 
-    fun computeMapOfRanges(methodName: String? = null): Map<String, IntRange> {
+    fun computeMapOfRangesForInstructionCoverage(methodName: String? = null): Map<String, IntRange> {
         val methodToListOfProbesInserter = MethodToProbesVisitor()
 
         visitClass(object : ClassVisitorBuilder<InstructionVisitorAdapter> {
@@ -49,12 +50,22 @@ class Instrumenter(classByteCode: ByteArray, val classLoader: ClassLoader? = nul
         return methodToListOfProbesInserter.methodToProbes.mapValues { (_, probes) -> (probes.first()..probes.last()) }
     }
 
+    fun computeMapOfRangesForBranchCoverage(): Map<String, IntRange> {
+        val methodToListOfProbesInserter = visitClass { writer ->
+            createClassVisitorForComputeMapOfRangesForBranchCoverage(writer)
+        }
+
+        return methodToListOfProbesInserter.methodToProbes.mapValues { (_, probes) -> (probes.first()..probes.last()) }
+    }
+
     fun addField(instanceFieldInitializer: InstanceFieldInitializer) {
         visitClass { writer -> AddFieldAdapter(writer, instanceFieldInitializer) }
     }
 
     fun addStaticField(staticFieldInitializer: StaticFieldInitializer) {
-        visitClass { writer -> AddStaticFieldAdapter(writer, staticFieldInitializer) }
+        visitClass { writer ->
+            AddStaticFieldAdapter(writer, staticFieldInitializer)
+        }
     }
 
     fun visitInstructions(instructionVisitor: IInstructionVisitor, methodName: String? = null) {
@@ -82,6 +93,7 @@ private class TunedClassWriter(
     override fun getClassLoader(): ClassLoader {
         return HandlerClassesLoader
     }
+
     override fun getCommonSuperClass(type1: String, type2: String): String {
         try {
             val info1 = typeInfo(type1)
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/visitors/util/InstructionVisitorMethodAdapter.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/visitors/util/InstructionVisitorMethodAdapter.kt
index bfff5b8014..5bd120e93f 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/visitors/util/InstructionVisitorMethodAdapter.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/instrumentation/instrumenter/visitors/util/InstructionVisitorMethodAdapter.kt
@@ -16,7 +16,7 @@ open class InstructionVisitorMethodAdapter(
     var lvs: LocalVariablesSorter? = null
 
     companion object {
-        private val returnInsns = setOf(
+        val returnInsns = setOf(
             Opcodes.IRETURN,
             Opcodes.LRETURN,
             Opcodes.FRETURN,
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt
index 12b2f996b3..b42d9217bd 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/process/InstrumentedProcessMain.kt
@@ -142,6 +142,7 @@ private fun InstrumentedProcessModel.setup(kryoHelper: KryoHelper, watchdog: Idl
         instrumentation = instrumentationFactory.create()
         logger.debug { "instrumentation - ${instrumentation.javaClass.name} " }
         Agent.dynamicClassTransformer.useBytecodeTransformation = params.useBytecodeTransformation
+        Agent.dynamicClassTransformer.traceInstrumentationType = kryoHelper.readObject(params.traceInstrumentationType)
         Agent.dynamicClassTransformer.transformer = instrumentation
         Agent.dynamicClassTransformer.addUserPaths(pathsToUserClasses)
         instrumentation.run { setupAdditionalRdResponses(kryoHelper, watchdog) }
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt
index d752643d3f..7a3a107144 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/InstrumentedProcess.kt
@@ -130,7 +130,8 @@ class InstrumentedProcess private constructor(
             proc.instrumentedProcessModel.setInstrumentation.startSuspending(
                 proc.lifetime, SetInstrumentationParams(
                     proc.kryoHelper.writeObject(instrumentationFactory),
-                    UtSettings.useBytecodeTransformation
+                    UtSettings.useBytecodeTransformation,
+                    proc.kryoHelper.writeObject(UtSettings.traceInstrumentationType)
                 )
             )
             logger.trace("start commands sent")
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/generated/InstrumentedProcessModel.Generated.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/generated/InstrumentedProcessModel.Generated.kt
index 2fe14c35d9..7a0fca7f14 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/generated/InstrumentedProcessModel.Generated.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/rd/generated/InstrumentedProcessModel.Generated.kt
@@ -64,7 +64,7 @@ class InstrumentedProcessModel private constructor(
         }
         
         
-        const val serializationHash = 8567129171874407469L
+        const val serializationHash = 4612832316394529233L
         
     }
     override val serializersOwner: ISerializersOwner get() = InstrumentedProcessModel
@@ -247,7 +247,7 @@ data class AddPathsParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:29]
+ * #### Generated from [InstrumentedProcessModel.kt:30]
  */
 data class CollectCoverageParams (
     val clazz: ByteArray
@@ -304,7 +304,7 @@ data class CollectCoverageParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:33]
+ * #### Generated from [InstrumentedProcessModel.kt:34]
  */
 data class CollectCoverageResult (
     val coverageInfo: ByteArray
@@ -361,7 +361,7 @@ data class CollectCoverageResult (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:37]
+ * #### Generated from [InstrumentedProcessModel.kt:38]
  */
 data class ComputeStaticFieldParams (
     val fieldId: ByteArray
@@ -418,7 +418,7 @@ data class ComputeStaticFieldParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:41]
+ * #### Generated from [InstrumentedProcessModel.kt:42]
  */
 data class ComputeStaticFieldResult (
     val result: ByteArray
@@ -475,7 +475,7 @@ data class ComputeStaticFieldResult (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:45]
+ * #### Generated from [InstrumentedProcessModel.kt:46]
  */
 data class GetSpringRepositoriesParams (
     val classId: ByteArray
@@ -532,7 +532,7 @@ data class GetSpringRepositoriesParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:49]
+ * #### Generated from [InstrumentedProcessModel.kt:50]
  */
 data class GetSpringRepositoriesResult (
     val springRepositoryIds: ByteArray
@@ -589,7 +589,7 @@ data class GetSpringRepositoriesResult (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:18]
+ * #### Generated from [InstrumentedProcessModel.kt:19]
  */
 data class InvokeMethodCommandParams (
     val classname: String,
@@ -664,7 +664,7 @@ data class InvokeMethodCommandParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:25]
+ * #### Generated from [InstrumentedProcessModel.kt:26]
  */
 data class InvokeMethodCommandResult (
     val result: ByteArray
@@ -725,7 +725,8 @@ data class InvokeMethodCommandResult (
  */
 data class SetInstrumentationParams (
     val instrumentation: ByteArray,
-    val useBytecodeTransformation: Boolean
+    val useBytecodeTransformation: Boolean,
+    val traceInstrumentationType: ByteArray
 ) : IPrintable {
     //companion
     
@@ -736,12 +737,14 @@ data class SetInstrumentationParams (
         override fun read(ctx: SerializationCtx, buffer: AbstractBuffer): SetInstrumentationParams  {
             val instrumentation = buffer.readByteArray()
             val useBytecodeTransformation = buffer.readBool()
-            return SetInstrumentationParams(instrumentation, useBytecodeTransformation)
+            val traceInstrumentationType = buffer.readByteArray()
+            return SetInstrumentationParams(instrumentation, useBytecodeTransformation, traceInstrumentationType)
         }
         
         override fun write(ctx: SerializationCtx, buffer: AbstractBuffer, value: SetInstrumentationParams)  {
             buffer.writeByteArray(value.instrumentation)
             buffer.writeBool(value.useBytecodeTransformation)
+            buffer.writeByteArray(value.traceInstrumentationType)
         }
         
         
@@ -759,6 +762,7 @@ data class SetInstrumentationParams (
         
         if (!(instrumentation contentEquals other.instrumentation)) return false
         if (useBytecodeTransformation != other.useBytecodeTransformation) return false
+        if (!(traceInstrumentationType contentEquals other.traceInstrumentationType)) return false
         
         return true
     }
@@ -767,6 +771,7 @@ data class SetInstrumentationParams (
         var __r = 0
         __r = __r*31 + instrumentation.contentHashCode()
         __r = __r*31 + useBytecodeTransformation.hashCode()
+        __r = __r*31 + traceInstrumentationType.contentHashCode()
         return __r
     }
     //pretty print
@@ -775,6 +780,7 @@ data class SetInstrumentationParams (
         printer.indent {
             print("instrumentation = "); instrumentation.print(printer); println()
             print("useBytecodeTransformation = "); useBytecodeTransformation.print(printer); println()
+            print("traceInstrumentationType = "); traceInstrumentationType.print(printer); println()
         }
         printer.print(")")
     }
@@ -784,7 +790,7 @@ data class SetInstrumentationParams (
 
 
 /**
- * #### Generated from [InstrumentedProcessModel.kt:53]
+ * #### Generated from [InstrumentedProcessModel.kt:54]
  */
 data class TryLoadingSpringContextResult (
     val springContextLoadingResult: ByteArray
diff --git a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/util/InstrumentationException.kt b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/util/InstrumentationException.kt
index 8a617f0168..2596e12e5f 100644
--- a/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/util/InstrumentationException.kt
+++ b/utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/util/InstrumentationException.kt
@@ -9,22 +9,33 @@ import org.utbot.framework.plugin.api.InstrumentedProcessDeathException
  */
 open class InstrumentationException(msg: String?, cause: Throwable? = null) : Exception(msg, cause)
 
-class NoProbesArrayException(clazz: Class<*>, arrayName: String) :
+abstract class NoFieldException(clazz: Class<*>, name: String, fieldName: String) :
     InstrumentationException(
-        "No probes array found\n\t" +
-                "Clazz: $clazz\n\t" +
-                "Probes array name: $arrayName\n\t" +
-                "All fields: ${clazz.fields.joinToString { it.name }}"
+        buildString {
+            appendLine("No $name found")
+            appendLine("\tClazz: $clazz")
+            appendLine("\t${name.capitalize()} name: $fieldName")
+            append("All fields: ${clazz.declaredFields.joinToString { it.name }}")
+        }
     )
 
+class NoProbesArrayException(clazz: Class<*>, arrayName: String) :
+    NoFieldException(clazz, "probes array", arrayName)
+
+class NoProbeCounterException(clazz: Class<*>, counterName: String) :
+    NoFieldException(clazz, "probe counter", counterName)
+
 class CastProbesArrayException :
     InstrumentationException("Can't cast probes array to Boolean array")
 
+class CastProbeCounterException :
+    InstrumentationException("Can't cast probe counter to Int")
+
 /**
  * this exception is thrown only in main process.
  * currently it means that {e: Throwable} happened in instrumented process,
  * but instrumented process still can operate and not dead.
  * on instrumented process death - [InstrumentedProcessDeathException] is thrown
-*/
+ */
 class InstrumentedProcessError(e: Throwable) :
     InstrumentationException("Error in the instrumented process |> ${e.stackTraceToString()}", e)
\ No newline at end of file
diff --git a/utbot-rd/src/main/rdgen/org/utbot/rd/models/InstrumentedProcessModel.kt b/utbot-rd/src/main/rdgen/org/utbot/rd/models/InstrumentedProcessModel.kt
index f9d3d76f50..bda3f70f2c 100644
--- a/utbot-rd/src/main/rdgen/org/utbot/rd/models/InstrumentedProcessModel.kt
+++ b/utbot-rd/src/main/rdgen/org/utbot/rd/models/InstrumentedProcessModel.kt
@@ -13,6 +13,7 @@ object InstrumentedProcessModel : Ext(InstrumentedProcessRoot) {
     val SetInstrumentationParams = structdef {
         field("instrumentation", array(PredefinedType.byte))
         field("useBytecodeTransformation", PredefinedType.bool)
+        field("traceInstrumentationType", array(PredefinedType.byte))
     }
 
     val InvokeMethodCommandParams = structdef {