diff --git a/.travis.yml b/.travis.yml
index 4ec0908ed..c1d7debc3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 env:
   global:
   - NODE_VERSION=6.11.1
-  - NDK_VERSION=r17b
+  - NDK_VERSION=r18b
   - DATE=$(date +%Y-%m-%d)
   - PACKAGE_VERSION=next-$DATE-$TRAVIS_BUILD_NUMBER
   - EMULATOR_API_LEVEL=21
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eec68ad38..a104a6efb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,29 @@
+5.2.0
+==
+
+## What's New
+ - [Upgrade v8 to 7.1.302.32(#1237)](https://github.com/NativeScript/android-runtime/issues/1237)
+ - [Add OnDiscardedError handler(#1245)](https://github.com/NativeScript/android-runtime/issues/1245)
+ - [Upgrade the android gradle plugin to the latest 3.3.0 version(#1251)](https://github.com/NativeScript/android-runtime/issues/1251)
+  - [Add android X support(#1226)](https://github.com/NativeScript/android-runtime/issues/1226)
+ - [Provide a JS helper function on the global object to release the native object wrapped by a JS instance(#1254)](https://github.com/NativeScript/android-runtime/issues/1254)
+
+## Bug Fixes
+
+ - [ClassNotFound exception when calling nested static class with correct argument(#1195)](https://github.com/NativeScript/android-runtime/issues/1195)
+ - [If you refresh or close the chrome dev tools window an error will be log in the console (#1202)](https://github.com/NativeScript/android-runtime/issues/1202)
+ - [Debug on Android fails when stopped on breakpoint and change in .xml/.css/.html is applied(#1243)](https://github.com/NativeScript/android-runtime/issues/1243)
+ - [Breakpoint stop to hit when you have two open tabs and close one(#1247)](https://github.com/NativeScript/android-runtime/issues/1247)
+ - [ClassNotFound exception when calling nested static class with correct argument(#1195)](https://github.com/NativeScript/android-runtime/issues/1195)
+ - [Upgrade V8 to v7 to fix unstable sort() method(#1176)](https://github.com/NativeScript/android-runtime/issues/1176)
+ - [CodeCache option is broken since Android Runtime 4.1.0(#1235)](https://github.com/NativeScript/android-runtime/issues/1235)
+ - [Snapshots with ABI splits do not work since Android Runtime 4.1.0(#1234)](https://github.com/NativeScript/android-runtime/issues/1234)
+
 5.1.0
 ==
 
 ## What's New
- - [Add a setting to wrap calls to CallJSMethod in try catch(#1223)](https://github.com/NativeScript/android-runtime/issues/12238)
+ - [Add a setting to wrap calls to CallJSMethod in try catch(#1223)](https://github.com/NativeScript/android-runtime/issues/1223)
  - [Support for abstract interface with static methods(#1157)](https://github.com/NativeScript/android-runtime/issues/1157)
  - [Use gradle plugin 3.2.1 instead of 3.2.0(#1209)](https://github.com/NativeScript/android-runtime/pull/1209)
  - [Add a concrete exception when the runtime cannot be found(#1201)](https://github.com/NativeScript/android-runtime/pull/1201)
diff --git a/LICENSE b/LICENSE
index 9d63a0a67..061c44028 100755
--- a/LICENSE
+++ b/LICENSE
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright (c) 2015-2018 Progress Software Corporation
+   Copyright (c) 2015-2019 Progress Software Corporation
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/build-artifacts/project-template-gradle/settings.json b/build-artifacts/project-template-gradle/settings.json
index 0e44c524d..256af84b8 100644
--- a/build-artifacts/project-template-gradle/settings.json
+++ b/build-artifacts/project-template-gradle/settings.json
@@ -1,3 +1,3 @@
 {
-    "v8Version": "6.9.427.23"
+    "v8Version": "7.1.302.32"
 }
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 98437f3be..e707855f4 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,7 +20,7 @@ def useCCache = !project.hasProperty("noCCache")
 def isWinOs = System.properties['os.name'].toLowerCase().contains('windows')
 def pVersion = "no package version was provided by build.gradle build"
 def arVersion = "no commit sha was provided by build.gradle build"
-def generateRegularRuntimePackage = !project.hasProperty("skipUnoptimized");
+def generateRegularRuntimePackage = !project.hasProperty("skipUnoptimized")
 
 def DIST_PATH = "$rootDir/dist"
 def TEST_APP_PATH = "$rootDir/test-app"
@@ -29,19 +29,19 @@ def DIST_FRAMEWORK_PATH = "$DIST_PATH/framework"
 
 task checkEnvironmentVariables {
     if ("$System.env.JAVA_HOME" == "" || "$System.env.JAVA_HOME" == "null") {
-        throw new GradleException("Set JAVA_HOME to point to the correct Jdk location\n");
+        throw new GradleException("Set JAVA_HOME to point to the correct Jdk location\n")
     }
 
     if ("$System.env.ANDROID_HOME" == "" || "$System.env.ANDROID_HOME" == "null") {
-        throw new GradleException("Set ANDROID_HOME to point to the correct Android SDK location\n");
+        throw new GradleException("Set ANDROID_HOME to point to the correct Android SDK location\n")
     }
 
     if ("$System.env.GIT_COMMIT" == "null" && !project.hasProperty("gitCommitVersion")) {
-        logger.warn("Warning: The GIT_COMMIT is not set. This NativeScript Android Runtime will not be tagged with the git commit it is build from\n");
+        logger.warn("Warning: The GIT_COMMIT is not set. This NativeScript Android Runtime will not be tagged with the git commit it is build from\n")
     }
 
     if (project.hasProperty("metadataGen") && !file("../android-metadata-generator/dist/tns-android-metadata-generator-0.0.1.tgz").exists()) {
-        throw new GradleException("android-metadata-generator build output not found and no metadataGen option specified. Build android-metadata-generator first.\n");
+        throw new GradleException("android-metadata-generator build output not found and no metadataGen option specified. Build android-metadata-generator first.\n")
     }
 }
 
@@ -120,9 +120,9 @@ task generateDtsgJar(type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         if (isWinOs) {
-            commandLine "cmd", "/c", "gradlew", ":dts-generator:jar"
+            commandLine "cmd", "/c", "gradlew", ":dts-generator:jar", "--warning-mode", "all"
         } else {
-            commandLine "./gradlew", ":dts-generator:jar"
+            commandLine "./gradlew", ":dts-generator:jar", "--warning-mode", "all"
         }
     }
 }
@@ -131,9 +131,9 @@ task generateSbgJar(type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         if (isWinOs) {
-            commandLine "cmd", "/c", "gradlew", ":static-binding-generator:jar"
+            commandLine "cmd", "/c", "gradlew", ":static-binding-generator:jar", "--warning-mode", "all"
         } else {
-            commandLine "./gradlew", ":static-binding-generator:jar"
+            commandLine "./gradlew", ":static-binding-generator:jar", "--warning-mode", "all"
         }
     }
 }
@@ -142,21 +142,9 @@ task generateMdgJar(type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         if (isWinOs) {
-            commandLine "cmd", "/c", "gradlew", ":android-metadata-generator:jar"
+            commandLine "cmd", "/c", "gradlew", ":android-metadata-generator:jar", "--warning-mode", "all"
         } else {
-            commandLine "./gradlew", ":android-metadata-generator:jar"
-        }
-    }
-}
-
-task generateRuntime {
-    doFirst {
-        tasks.generateOptimizedRuntimeAar.execute();
-
-        tasks.generateOptimizedWithInspectorRuntimeAar.execute();
-
-        if (generateRegularRuntimePackage) {
-            tasks.generateRuntimeAar.execute();
+            commandLine "./gradlew", ":android-metadata-generator:jar", "--warning-mode", "all"
         }
     }
 }
@@ -165,9 +153,9 @@ task cleanRuntime (type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         if (isWinOs) {
-            commandLine "cmd", "/c", "gradlew", ":runtime:clean"
+            commandLine "cmd", "/c", "gradlew", ":runtime:clean", "--warning-mode", "all"
         } else {
-            commandLine "./gradlew", ":runtime:clean"
+            commandLine "./gradlew", ":runtime:clean", "--warning-mode", "all"
         }
     }
 }
@@ -177,23 +165,24 @@ def getAssembleReleaseBuildArguments = { ->
     if (isWinOs) {
         arguments += ["cmd", "/c", "gradlew"]
     } else {
-        arguments.push("./gradlew")
+        arguments.add("./gradlew")
     }
     arguments += [":runtime:assembleRelease", "-PpackageVersion=${pVersion}", "-PgitCommitVersion=${arVersion}"]
     if (onlyX86) {
-        arguments.push("-PonlyX86")
+        arguments.add("-PonlyX86")
     }
     if (useCCache) {
-        arguments.push("-PuseCCache")
+        arguments.add("-PuseCCache")
     }
-    return arguments;
+    arguments += ["--warning-mode", "all"]
+    return arguments
 }
 
 task generateOptimizedRuntimeAar (type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         def arguments = getAssembleReleaseBuildArguments()
-        arguments.push("-Poptimized")
+        arguments.add("-Poptimized")
         commandLine arguments
     }
 }
@@ -202,7 +191,7 @@ task generateOptimizedWithInspectorRuntimeAar (type: Exec) {
     doFirst {
         workingDir "$TEST_APP_PATH"
         def arguments = getAssembleReleaseBuildArguments()
-        arguments.push("-PoptimizedWithInspector")
+        arguments.add("-PoptimizedWithInspector")
         commandLine arguments
     }
 }
@@ -316,7 +305,7 @@ task setPackageVersionInPackageJsonFile {
         def inputFile = new File("$DIST_PATH/package.json")
         def json = new JsonSlurper().parseText(inputFile.text)
         json.version = pVersion
-        def jb = new JsonBuilder(json);
+        def jb = new JsonBuilder(json)
         inputFile.text = JsonOutput.prettyPrint(jb.toString())
     }
 }
@@ -344,9 +333,17 @@ createDistDir.dependsOn(generateMdgJar)
 
 getPackageVersion.dependsOn(createDistDir)
 getCommitVersion.dependsOn(getPackageVersion)
-generateRuntime.dependsOn(getCommitVersion)
+generateOptimizedRuntimeAar.dependsOn(getCommitVersion)
+
+generateOptimizedWithInspectorRuntimeAar.dependsOn(generateOptimizedRuntimeAar)
+
+if (generateRegularRuntimePackage) {
+    generateRuntimeAar.dependsOn(generateOptimizedWithInspectorRuntimeAar)
+    buildJsParser.dependsOn(generateRuntimeAar)
+} else {
+    buildJsParser.dependsOn(generateOptimizedWithInspectorRuntimeAar)
+}
 
-buildJsParser.dependsOn(generateRuntime)
 copyFilesToProjectTemeplate.dependsOn(buildJsParser)
 copyProjectTemplate.dependsOn(copyFilesToProjectTemeplate)
 copyPackageJson.dependsOn(copyProjectTemplate)
@@ -377,9 +374,9 @@ task runSbgTests (type: Exec, dependsOn: 'runAstTests') {
     doFirst {
         workingDir "$TEST_APP_PATH"
         if (isWinOs) {
-            commandLine "cmd", "/c", "gradlew", ":static-binding-generator:test"
+            commandLine "cmd", "/c", "gradlew", ":static-binding-generator:test", "--warning-mode", "all"
         } else {
-            commandLine "./gradlew", ":static-binding-generator:test"
+            commandLine "./gradlew", ":static-binding-generator:test", "--warning-mode", "all"
         }
     }
 }
@@ -389,16 +386,17 @@ def getRunTestsBuildArguments = { taskName ->
     if (isWinOs) {
         arguments += ["cmd", "/c", "gradlew"]
     } else {
-        arguments.push("./gradlew")
+        arguments.add("./gradlew")
     }
-    arguments +=["-b", "runtests.gradle", taskName]
+    arguments += ["-b", "runtests.gradle", taskName]
     if (onlyX86) {
-        arguments.push("-PonlyX86")
+        arguments.add("-PonlyX86")
     }
     if (useCCache) {
-        arguments.push("-PuseCCache")
+        arguments.add("-PuseCCache")
     }
-    return arguments;
+    arguments += ["--warning-mode", "all"]
+    return arguments
 }
 
 task runTests (type: Exec) {
diff --git a/package.json b/package.json
index 97babe952..e4789b802 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "tns-android",
   "description": "NativeScript Runtime for Android",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/NativeScript/android-runtime.git"
@@ -10,7 +10,8 @@
     "**/*"
   ],
   "gradle": {
-      "version": "4.10.2",
-      "android": "3.2.1"
-  }
+    "version": "4.10.2",
+    "android": "3.3.0"
+  },
+  "android_ndk_version": "18b"
 }
diff --git a/test-app/app/build.gradle b/test-app/app/build.gradle
index b35f451b9..e1bd57679 100644
--- a/test-app/app/build.gradle
+++ b/test-app/app/build.gradle
@@ -145,30 +145,30 @@ def applyPluginGradleConfigurations = { ->
 }
 
 def getAppIdentifier = { packageJsonMap ->
-	def appIdentifier = "";
+	def appIdentifier = ""
 	if (packageJsonMap && packageJsonMap.nativescript) {
-		appIdentifier = packageJsonMap.nativescript.id;
+		appIdentifier = packageJsonMap.nativescript.id
 		if (!(appIdentifier instanceof String)) {
-			appIdentifier = appIdentifier.android;
+			appIdentifier = appIdentifier.android
 		}
 	}
 
-	return appIdentifier;
+	return appIdentifier
 }
 
 def setAppIdentifier = { ->
-	println "\t + setting applicationId";
-	File packageJsonFile = new File("$rootDir/../../package.json");
+	println "\t + setting applicationId"
+	File packageJsonFile = new File("$rootDir/../../package.json")
 
 	if (packageJsonFile.exists()) {
-		def content = packageJsonFile.getText("UTF-8");
-		def jsonSlurper = new JsonSlurper();
-		def packageJsonMap = jsonSlurper.parseText(content);
-		def appIdentifier = getAppIdentifier(packageJsonMap);
+		def content = packageJsonFile.getText("UTF-8")
+		def jsonSlurper = new JsonSlurper()
+		def packageJsonMap = jsonSlurper.parseText(content)
+		def appIdentifier = getAppIdentifier(packageJsonMap)
 
 		if (appIdentifier) {
-			project.ext.nsApplicationIdentifier = appIdentifier;
-			android.defaultConfig.applicationId = appIdentifier;
+			project.ext.nsApplicationIdentifier = appIdentifier
+			android.defaultConfig.applicationId = appIdentifier
 		}
 	}
 }
@@ -267,12 +267,36 @@ dependencies {
         supportVer = supportVersion
     }
 
-    println "Using support library version $supportVer"
+    if (project.hasProperty("useAndroidX") && (useAndroidX || useAndroidX.toBoolean())) {
+        def androidXLegacyVersion = "1.0.0"
+        if (project.hasProperty("androidXLegacy")) {
+            androidXLegacyVersion = androidXLegacy
+        }
+
+        def androidXAppCompatVersion = "1.1.0-alpha01"
+        if (project.hasProperty("androidXAppCompat")) {
+            androidXAppCompatVersion = androidXAppCompat
+        }
+
+        def androidXMaterialVersion = "1.1.0-alpha01"
+        if (project.hasProperty("androidXMaterial")) {
+            androidXMaterialVersion = androidXMaterial
+        }
 
-    implementation "com.android.support:multidex:1.0.2"
-    implementation "com.android.support:support-v4:$supportVer"
-    implementation "com.android.support:appcompat-v7:$supportVer"
-    implementation "com.android.support:design:$supportVer"
+        println "\t + using andorid X library androidx.legacy:legacy-support-v4:$androidXLegacyVersion"
+
+        implementation "androidx.multidex:multidex:2.0.0"
+        implementation "androidx.legacy:legacy-support-v4:$androidXLegacyVersion"
+        implementation "androidx.appcompat:appcompat:$androidXAppCompatVersion"
+        implementation "com.google.android.material:material:$androidXMaterialVersion"
+    } else {
+        println "\t + using support library version $supportVer"
+
+        implementation "com.android.support:multidex:1.0.2"
+        implementation "com.android.support:support-v4:$supportVer"
+        implementation "com.android.support:appcompat-v7:$supportVer"
+        implementation "com.android.support:design:$supportVer"
+    }
 
     def sbgProjectExists = !findProject(':static-binding-generator').is(null)
     if (sbgProjectExists) {
@@ -364,12 +388,13 @@ tasks.whenTaskAdded({ org.gradle.api.DefaultTask currentTask ->
         extractAllJars.finalizedBy(collectAllJars)
     }
     if (currentTask =~ /compile.+JavaWithJavac/) {
+        currentTask.dependsOn(makeAndroidXChanges)
         currentTask.dependsOn(runSbg)
         currentTask.finalizedBy(ensureMetadataOutDir)
         ensureMetadataOutDir.finalizedBy(buildMetadata)
     }
     if (currentTask =~ /merge.*Assets/) {
-        currentTask.shouldRunAfter(buildMetadata);
+        currentTask.shouldRunAfter(buildMetadata)
     }
     if (currentTask =~ /assemble.*Debug/ || currentTask =~ /assemble.*Release/) {
         currentTask.finalizedBy("validateAppIdMatch")
@@ -388,7 +413,7 @@ task runSbg(type: JavaExec) {
     args "static-binding-generator.jar"
 
     doFirst {
-        new File("$OUTPUT_JAVA_DIR/com/tns/gen").deleteDir();
+        new File("$OUTPUT_JAVA_DIR/com/tns/gen").deleteDir()
     }
 }
 
@@ -534,6 +559,43 @@ task buildMetadata(type: JavaExec) {
     }
 }
 
+task makeAndroidXChanges {
+    if (project.hasProperty("useAndroidX") && (useAndroidX || useAndroidX.toBoolean())) {
+        // code changes
+        def codeTuples = new ArrayList<Tuple2<String, String>>()
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.annotation\\.NonNull', 'androidx.annotation.NonNull'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v7\\.app\\.AppCompatActivity', 'androidx.appcompat.app.AppCompatActivity'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v7\\.appcompat\\.R', 'androidx.appcompat.R'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.design\\.widget\\.TabLayout', 'com.google.android.material.tabs.TabLayout'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v4\\.app\\.ActivityCompat', 'androidx.core.app.ActivityCompat'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v4\\.app\\.Fragment', 'androidx.fragment.app.Fragment'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v4\\.view\\.ViewPager', 'androidx.viewpager.widget.ViewPager'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.v7\\.widget\\.Toolbar', 'androidx.appcompat.widget.Toolbar'))
+        codeTuples.add(new Tuple2<String, String>('android\\.support\\.multidex\\.MultiDex', 'androidx.multidex.MultiDex'))
+
+        codeTuples.each { tuple ->
+            ant.replaceregexp(match: tuple.first, replace: tuple.second, flags: 'g', byline: true) {
+                fileset(dir: "$projectDir/src/debug/java/com/tns/", includes: '*.java')
+            }
+            ant.replaceregexp(match: tuple.first, replace: tuple.second, flags: 'g', byline: true) {
+                fileset(dir: "$projectDir/src/main/java/com/tns/", includes: '*.java')
+            }
+        }
+
+        // resource changes
+        def resourceTuples = new ArrayList<Tuple2<String, String>>()
+        resourceTuples.add(new Tuple2<String, String>('android\\.support\\.v7\\.widget\\.Toolbar', 'androidx.appcompat.widget.Toolbar'))
+        resourceTuples.add(new Tuple2<String, String>('android\\.support\\.v4\\.view\\.ViewPager', 'androidx.viewpager.widget.ViewPager'))
+        resourceTuples.add(new Tuple2<String, String>('android\\.support\\.design\\.widget\\.TabLayout', 'com.google.android.material.tabs.TabLayout'))
+
+        resourceTuples.each { tuple ->
+            ant.replaceregexp(match: tuple.first, replace: tuple.second, flags: 'g', byline: true) {
+                fileset(dir: "$projectDir/src/debug/res/layout/", includes: 'error_activity.xml')
+            }
+        }
+    }
+}
+
 task generateTypescriptDefinitions(type: JavaExec) {
     def paramz = new ArrayList<String>()
     def includeDirs = ["com.android.support", "/platforms/" + android.compileSdkVersion]
@@ -606,7 +668,7 @@ task validateAppIdMatch {
 					"NativeScript CLI might not work properly.$lineSeparator" +
 					"Remove applicationId from app.gradle and update the \"nativescript.id\" in package.json.$lineSeparator" +
 					"Actual: ${android.defaultConfig.applicationId}$lineSeparator" +
-					"Expected(from \"package.json\"): ${project.nsApplicationIdentifier}$lineSeparator";
+					"Expected(from \"package.json\"): ${project.nsApplicationIdentifier}$lineSeparator"
 
 				logger.error(errorMessage)
 			}
diff --git a/test-app/app/src/debug/java/com/tns/ErrorReport.java b/test-app/app/src/debug/java/com/tns/ErrorReport.java
index 796325d62..8fb9864c0 100644
--- a/test-app/app/src/debug/java/com/tns/ErrorReport.java
+++ b/test-app/app/src/debug/java/com/tns/ErrorReport.java
@@ -22,7 +22,6 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
-import android.graphics.Color;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
diff --git a/test-app/app/src/debug/java/com/tns/NativeScriptSyncServiceSocketImpl.java b/test-app/app/src/debug/java/com/tns/NativeScriptSyncServiceSocketImpl.java
index c75d178c8..5bd2f8a6e 100644
--- a/test-app/app/src/debug/java/com/tns/NativeScriptSyncServiceSocketImpl.java
+++ b/test-app/app/src/debug/java/com/tns/NativeScriptSyncServiceSocketImpl.java
@@ -165,7 +165,7 @@ public void run() {
 
                         validateData();
                         if(runtime != null && doRefreshInt == DO_REFRESH_VALUE) {
-                            runtime.runScript(new File(NativeScriptSyncServiceSocketImpl.this.context.getFilesDir(), "internal/livesync.js"));
+                            runtime.runScript(new File(NativeScriptSyncServiceSocketImpl.this.context.getFilesDir(), "internal/livesync.js"), false);
                             operationReportCode = OPERATION_END_REPORT_CODE;
                         } else {
                             operationReportCode = OPERATION_END_NO_REFRESH_REPORT_CODE;
diff --git a/test-app/app/src/main/assets/app/MyActivity.js b/test-app/app/src/main/assets/app/MyActivity.js
index e108d1505..5895c9c9f 100644
--- a/test-app/app/src/main/assets/app/MyActivity.js
+++ b/test-app/app/src/main/assets/app/MyActivity.js
@@ -13,7 +13,7 @@
 	}
 	
 	@JavaProxy("com.tns.NativeScriptActivity")
-	class MyActivity extends android.app.Activity
+	class MyActivity extends android.support.v7.app.AppCompatActivity
 	{
 		onCreate(bundle: android.os.Bundle) 
 		{
@@ -61,4 +61,4 @@ var MyActivity = (function (_super) {
         JavaProxy("com.tns.NativeScriptActivity")
     ], MyActivity);
     return MyActivity;
-})(android.app.Activity);
\ No newline at end of file
+})(android.support.v7.app.AppCompatActivity);
\ No newline at end of file
diff --git a/test-app/app/src/main/assets/app/mainpage.js b/test-app/app/src/main/assets/app/mainpage.js
index 624a647b1..ae814e00e 100644
--- a/test-app/app/src/main/assets/app/mainpage.js
+++ b/test-app/app/src/main/assets/app/mainpage.js
@@ -34,6 +34,7 @@ require("./tests/testPrimitiveTypeConversion");
 require("./tests/numericConversionTests");
 require("./tests/inheritanceChainResolutionTest");
 require("./tests/exceptionHandlingTests");
+require("./tests/discardedExceptionsTest");
 require("./tests/dispatchCallbacksOnUiThreadTests");
 require("./tests/stringConversionTests");
 require("./tests/testsForTypescript");
@@ -51,4 +52,5 @@ require("./tests/byte-buffer-test");
 require("./tests/dex-interface-implementation");
 require("./tests/testInterfaceImplementation");
 require("./tests/testRuntimeImplementedAPIs");
-require("./tests/testsInstanceOfOperator");
\ No newline at end of file
+require("./tests/testsInstanceOfOperator");
+require("./tests/testReleaseNativeCounterpart");
\ No newline at end of file
diff --git a/test-app/app/src/main/assets/app/modules/libCalc-arm.so b/test-app/app/src/main/assets/app/modules/libCalc-arm.so
index d5d3a4c5b..6d3f450a4 100755
Binary files a/test-app/app/src/main/assets/app/modules/libCalc-arm.so and b/test-app/app/src/main/assets/app/modules/libCalc-arm.so differ
diff --git a/test-app/app/src/main/assets/app/modules/libCalc-arm64.so b/test-app/app/src/main/assets/app/modules/libCalc-arm64.so
index 0101abdb7..704534a40 100755
Binary files a/test-app/app/src/main/assets/app/modules/libCalc-arm64.so and b/test-app/app/src/main/assets/app/modules/libCalc-arm64.so differ
diff --git a/test-app/app/src/main/assets/app/modules/libCalc-x86.so b/test-app/app/src/main/assets/app/modules/libCalc-x86.so
index 078aa7233..cf8c97641 100755
Binary files a/test-app/app/src/main/assets/app/modules/libCalc-x86.so and b/test-app/app/src/main/assets/app/modules/libCalc-x86.so differ
diff --git a/test-app/app/src/main/assets/app/tests/discardedExceptionsTest.js b/test-app/app/src/main/assets/app/tests/discardedExceptionsTest.js
new file mode 100644
index 000000000..90d0370ba
--- /dev/null
+++ b/test-app/app/src/main/assets/app/tests/discardedExceptionsTest.js
@@ -0,0 +1,27 @@
+describe("Tests discarded exception ", function () {
+    var originalOnDiscardedError = null;
+
+    beforeEach(function() {
+      originalOnDiscardedError = global.__onDiscardedError;
+    });
+
+    it("should report discarded exception", function () {
+        var reportedException = null;
+
+        global.__onDiscardedError = (error) => {
+            reportedException = error;
+        }
+
+        var test = new com.tns.tests.DiscardedExceptionTest();
+        test.reportSupressedException();
+
+        expect(reportedException).not.toBe(null);
+        expect(reportedException.nativeException).not.toBe(null);
+        expect(reportedException.nativeException.getMessage()).toBe('Exception to suppress');
+        expect(reportedException.stackTrace).toContain('Error on "main" thread for reportSupressedException');
+    });
+
+    afterEach(function() {
+      global.__onDiscardedError = originalOnDiscardedError;
+    });
+});
\ No newline at end of file
diff --git a/test-app/app/src/main/assets/app/tests/exceptionHandlingTests.js b/test-app/app/src/main/assets/app/tests/exceptionHandlingTests.js
index 742b8ac4a..5deab7438 100644
--- a/test-app/app/src/main/assets/app/tests/exceptionHandlingTests.js
+++ b/test-app/app/src/main/assets/app/tests/exceptionHandlingTests.js
@@ -31,12 +31,10 @@ describe("Tests exception handling ", function () {
 
 		var eh = new EH();
 
-		try
-		{
+		try {
 			eh.triggerEvent1("test", 5);
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 			sameExObject = e === ex;
 			__log("e=" + e);
@@ -71,16 +69,13 @@ describe("Tests exception handling ", function () {
 
 		var eh = new EH();
 
-		try
-		{
+		try {
 			eh.triggerEvent1("test", 5);
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 			nativeExceptionFound = e.nativeException !== undefined;
-			if (nativeExceptionFound)
-			{
+			if (nativeExceptionFound) {
 				exMsg = e.nativeException.getMessage();
 			}
 		}
@@ -111,13 +106,11 @@ describe("Tests exception handling ", function () {
 
 		var eh = new EH();
 
-		try
-		{
+		try {
 			eh.triggerEvent1WithCatchClause("test", 5);
 			exceptionCaught = false;
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -147,13 +140,11 @@ describe("Tests exception handling ", function () {
 
 		var eh = new EH();
 
-		try
-		{
+		try {
 			eh.triggerEvent1WithCatchClause("test", 5);
 			exceptionCaught = false;
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -169,12 +160,10 @@ describe("Tests exception handling ", function () {
 
 		var dummy = new com.tns.tests.DummyClass();
 
-		try
-		{
+		try {
 			dummy.methodThatThrowsException();
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -190,12 +179,10 @@ describe("Tests exception handling ", function () {
 
 		var dummy = new com.tns.tests.DummyClass();
 
-		try
-		{
+		try {
 			dummy.methodThatThrowsException();
 		}
-		catch (e)
-		{
+		catch (e) {
 			var nativeException = e.nativeException;
 		}
 
@@ -214,12 +201,10 @@ describe("Tests exception handling ", function () {
 
 		var exceptionCaught = false;
 
-		try
-		{
+		try {
 			var dummy = new com.tns.tests.DummyClass(true /* throwsException */);
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -240,14 +225,12 @@ describe("Tests exception handling ", function () {
 
 		expect(arrLength).toEqual(1);
 
-		try
-		{
+		try {
 			var dummy = arr[arrLength];
 
 			var name = dummy.getName();
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -270,12 +253,10 @@ describe("Tests exception handling ", function () {
 
 		var last = arr[arrLength - 1];
 
-		try
-		{
+		try {
 			arr[arrLength] = last;
 		}
-		catch (e)
-		{
+		catch (e) {
 			exceptionCaught = true;
 		}
 
@@ -335,8 +316,8 @@ describe("Tests exception handling ", function () {
 	    }
 	    expect(exceptionCaught).toBe(true);
 	    expect(errMsg).toContain("Cannot compile /data/data/com.tns.testapplication/files/app/tests/syntaxErrors.js");
-	    expect(errMsg).toContain("SyntaxError: Unexpected token =");
-	    expect(errMsg).toContain("File: \"file:///data/data/com.tns.testapplication/files/app/tests/syntaxErrors.js, line: 3, column: 10");
+	    expect(errMsg).toContain("SyntaxError: Unexpected token class");
+	    expect(errMsg).toContain("File: \"file:///data/data/com.tns.testapplication/files/app/tests/syntaxErrors.js, line: 3, column: 4");
 	});
 
     // run this test only for API level bigger than 25 as we have handling there
diff --git a/test-app/app/src/main/assets/app/tests/testReleaseNativeCounterpart.js b/test-app/app/src/main/assets/app/tests/testReleaseNativeCounterpart.js
new file mode 100644
index 000000000..4bd78ce65
--- /dev/null
+++ b/test-app/app/src/main/assets/app/tests/testReleaseNativeCounterpart.js
@@ -0,0 +1,81 @@
+describe("Test native counterpart release", function () {
+
+	var myCustomEquality = function(first, second) {
+		return first == second;
+	};
+
+	beforeEach(function() {
+		jasmine.addCustomEqualityTester(myCustomEquality);
+	});
+
+	it("Calling a method on a released object should throw exception", function () {
+
+		var errorMessage = "";
+
+		try{
+		    var object1 = new java.lang.Object();
+
+		    global.__releaseNativeCounterpart(object1);
+
+		    object1.toString();
+		} catch(e){
+		    errorMessage = e.message;
+		}
+
+		expect(errorMessage).toBe("Failed calling toString on a java/lang/Object instance. The JavaScript instance no longer has available Java instance counterpart.");
+	});
+
+    it("Calling release on a non native object should throw exception", function () {
+
+        var errorMessage = "";
+
+        try{
+            var object2 = {prop: "test"};
+            global.__releaseNativeCounterpart(object2);
+        } catch(e){
+            errorMessage = e.message;
+        }
+
+        expect(errorMessage).toBe("Trying to release a non native object!");
+    });
+
+
+    it("Calling release on a non native primitive type should throw exception", function () {
+
+        var errorMessage = "";
+
+        try{
+            global.__releaseNativeCounterpart(42);
+        } catch(e){
+            errorMessage = e.message;
+        }
+
+        expect(errorMessage).toBe("Argument is not an object!");
+    });
+
+    it("Calling the __releaseNativeCounterpart function with 0 arguments should throw exception", function(){
+        var errorMessage = "";
+
+        try{
+            global.__releaseNativeCounterpart();
+        } catch(e){
+            errorMessage = e.message;
+        }
+
+        expect(errorMessage).toBe("Unexpected arguments count!");
+    });
+
+    it("Calling the __releaseNativeCounterpart function with more than 1 arguments should throw exception", function(){
+        var errorMessage = "";
+
+        try{
+            global.__releaseNativeCounterpart({},{});
+        } catch(e){
+            errorMessage = e.message;
+        }
+
+        expect(errorMessage).toBe("Unexpected arguments count!");
+    });
+
+
+});
\ No newline at end of file
diff --git a/test-app/app/src/main/assets/app/tests/testsWithContext.js b/test-app/app/src/main/assets/app/tests/testsWithContext.js
index 958d12589..b8c0082c9 100644
--- a/test-app/app/src/main/assets/app/tests/testsWithContext.js
+++ b/test-app/app/src/main/assets/app/tests/testsWithContext.js
@@ -116,13 +116,15 @@ exports.run = function(cntxt)
 		it("TestOldAPIForGettingMethodsListForMethodsWithParametersFromMissingType", function () {
             __log("TEST: TestOldAPIForGettingMethodsListForMethodsWithParametersFromMissingType");
 
-            var til = new android.support.design.widget.TextInputLayout(context);
-            var editText = new android.widget.EditText(context);
-            var relativeLayout = new android.widget.RelativeLayout(context);
-            var relativeLayoutParams = new android.widget.RelativeLayout.LayoutParams(android.widget.RelativeLayout.LayoutParams.MATCH_PARENT, android.widget.RelativeLayout.LayoutParams.MATCH_PARENT);
-            relativeLayout.setLayoutParams(relativeLayoutParams);
-            editText.setHint("TEST");
-            til.addView(editText);
+            if(android.support.design && android.support.design.widget) {
+                var til = new android.support.design.widget.TextInputLayout(context);
+                var editText = new android.widget.EditText(context);
+                var relativeLayout = new android.widget.RelativeLayout(context);
+                var relativeLayoutParams = new android.widget.RelativeLayout.LayoutParams(android.widget.RelativeLayout.LayoutParams.MATCH_PARENT, android.widget.RelativeLayout.LayoutParams.MATCH_PARENT);
+                relativeLayout.setLayoutParams(relativeLayoutParams);
+                editText.setHint("TEST");
+                til.addView(editText);
+            }
         });
 	});
 };
\ No newline at end of file
diff --git a/test-app/app/src/main/java/com/tns/AndroidJsV8Inspector.java b/test-app/app/src/main/java/com/tns/AndroidJsV8Inspector.java
index df9a1a891..5c3996f24 100644
--- a/test-app/app/src/main/java/com/tns/AndroidJsV8Inspector.java
+++ b/test-app/app/src/main/java/com/tns/AndroidJsV8Inspector.java
@@ -23,8 +23,6 @@
 import fi.iki.elonen.NanoWSD;
 
 class AndroidJsV8Inspector {
-    private static boolean DEBUG_LOG_ENABLED = false;
-
     private JsV8InspectorServer server;
     private static String ApplicationDir;
     private String packageName;
@@ -43,6 +41,8 @@ class AndroidJsV8Inspector {
 
     private final Object debugBrkLock;
 
+    private Logger currentRuntimeLogger;
+
     private static AtomicBoolean ReadyToProcessMessages = new AtomicBoolean(false);
 
     private LinkedBlockingQueue<String> inspectorMessages = new LinkedBlockingQueue<String>();
@@ -60,10 +60,12 @@ public void start() throws IOException {
 
             mainHandler = currentRuntime.getHandler();
 
-            this.server = new JsV8InspectorServer(this.packageName + "-inspectorServer");
+            currentRuntimeLogger = currentRuntime.getLogger();
+
+            this.server = new JsV8InspectorServer(this.packageName + "-inspectorServer", currentRuntimeLogger);
             this.server.start(-1);
 
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("V8Inspector", "start debugger ThreadId:" + Thread.currentThread().getId());
             }
 
@@ -158,22 +160,22 @@ private static String getMimeType(String url) {
             // getMimeType may sometime return incorrect results in the context of NativeScript
             // e.g. `.ts` returns video/MP2TS
             switch (extension) {
-            case "js":
-                type = "text/javascript";
-                break;
-            case "json":
-                type = "application/json";
-                break;
-            case "css":
-                type = "text/css";
-                break;
-            case "ts":
-                type = "text/typescript";
-                break;
-            // handle shared libraries so they are marked properly and don't appear in the sources tab
-            case "so":
-                type = "application/binary";
-                break;
+                case "js":
+                    type = "text/javascript";
+                    break;
+                case "json":
+                    type = "application/json";
+                    break;
+                case "css":
+                    type = "text/css";
+                    break;
+                case "ts":
+                    type = "text/typescript";
+                    break;
+                // handle shared libraries so they are marked properly and don't appear in the sources tab
+                case "so":
+                    type = "application/binary";
+                    break;
             }
         }
 
@@ -214,13 +216,16 @@ private void processDebugBreakMessages() {
     }
 
     private class JsV8InspectorServer extends NanoWSD {
-        JsV8InspectorServer(String name) {
+        private Logger currentRuntimeLogger;
+
+        JsV8InspectorServer(String name, Logger runtimeLogger) {
             super(name);
+            currentRuntimeLogger = runtimeLogger;
         }
 
         @Override
         protected Response serveHttp(IHTTPSession session) {
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("{N}.v8-inspector", "http request for " + session.getUri());
             }
             return super.serveHttp(session);
@@ -228,18 +233,21 @@ protected Response serveHttp(IHTTPSession session) {
 
         @Override
         protected WebSocket openWebSocket(IHTTPSession handshake) {
-            return new JsV8InspectorWebSocket(handshake);
+            return new JsV8InspectorWebSocket(handshake, currentRuntimeLogger);
         }
     }
 
     private class JsV8InspectorWebSocket extends NanoWSD.WebSocket {
-        JsV8InspectorWebSocket(NanoHTTPD.IHTTPSession handshakeRequest) {
+        private Logger currentRuntimeLogger;
+
+        JsV8InspectorWebSocket(NanoHTTPD.IHTTPSession handshakeRequest, Logger runtimeLogger) {
             super(handshakeRequest);
+            currentRuntimeLogger = runtimeLogger;
         }
 
         @Override
         protected void onOpen() {
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("V8Inspector", "onOpen: ThreadID:  " + Thread.currentThread().getId());
             }
 
@@ -248,14 +256,14 @@ protected void onOpen() {
 
         @Override
         protected void onClose(NanoWSD.WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) {
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("V8Inspector", "onClose");
             }
 
             mainHandler.post(new Runnable() {
                 @Override
                 public void run() {
-                    if (DEBUG_LOG_ENABLED) {
+                    if (currentRuntimeLogger.isEnabled()) {
                         Log.d("V8Inspector", "Disconnecting");
                     }
                     disconnect();
@@ -265,7 +273,7 @@ public void run() {
 
         @Override
         protected void onMessage(final NanoWSD.WebSocketFrame message) {
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("V8Inspector", "To dbg backend: " + message.getTextPayload() + " ThreadId:" + Thread.currentThread().getId());
             }
 
@@ -299,7 +307,7 @@ public void run() {
 
         @Override
         public void send(String payload) throws IOException {
-            if (DEBUG_LOG_ENABLED) {
+            if (currentRuntimeLogger.isEnabled()) {
                 Log.d("V8Inspector", "To dbg client: " + payload);
             }
 
@@ -322,7 +330,10 @@ protected void onPong(NanoWSD.WebSocketFrame pong) {
 
         @Override
         protected void onException(IOException exception) {
-            exception.printStackTrace();
+            // when the chrome inspector is disconnected by closing the tab a "Broken pipe" exception is thrown which we don't need to log, only in verbose logging mode
+            if(!exception.getMessage().equals("Broken pipe") || currentRuntimeLogger.isEnabled()) {
+                exception.printStackTrace();
+            }
             disconnect();
         }
     }
diff --git a/test-app/app/src/main/java/com/tns/NativeScriptUncaughtExceptionHandler.java b/test-app/app/src/main/java/com/tns/NativeScriptUncaughtExceptionHandler.java
index 92c75e6c5..087f7e7d2 100644
--- a/test-app/app/src/main/java/com/tns/NativeScriptUncaughtExceptionHandler.java
+++ b/test-app/app/src/main/java/com/tns/NativeScriptUncaughtExceptionHandler.java
@@ -21,7 +21,7 @@ public NativeScriptUncaughtExceptionHandler(Logger logger, Context context) {
     public void uncaughtException(Thread thread, Throwable ex) {
         String currentThreadMessage = "An uncaught Exception occurred on \"" + thread.getName() + "\" thread.\n";
 
-        String errorMessage = currentThreadMessage + getErrorMessage(ex);
+        String errorMessage = currentThreadMessage + Runtime.getStackTraceErrorMessage(ex);
 
         if (Runtime.isInitialized()) {
             try {
@@ -64,27 +64,4 @@ public void uncaughtException(Thread thread, Throwable ex) {
             defaultHandler.uncaughtException(thread, ex);
         }
     }
-
-    private static String getErrorMessage(Throwable ex) {
-        String content;
-        java.io.PrintStream ps = null;
-
-        try {
-            java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-            ps = new java.io.PrintStream(baos);
-            ex.printStackTrace(ps);
-
-            try {
-                content = baos.toString("US-ASCII");
-            } catch (java.io.UnsupportedEncodingException e) {
-                content = e.getMessage();
-            }
-        } finally {
-            if (ps != null) {
-                ps.close();
-            }
-        }
-
-        return content;
-    }
 }
diff --git a/test-app/app/src/main/java/com/tns/tests/DiscardedExceptionTest.java b/test-app/app/src/main/java/com/tns/tests/DiscardedExceptionTest.java
new file mode 100644
index 000000000..74959fd84
--- /dev/null
+++ b/test-app/app/src/main/java/com/tns/tests/DiscardedExceptionTest.java
@@ -0,0 +1,11 @@
+package com.tns.tests;
+
+public class DiscardedExceptionTest {
+    public void reportSupressedException() {
+        try {
+            throw new Exception("Exception to suppress");
+        } catch (Throwable ex) {
+            com.tns.Runtime.passSuppressedExceptionToJs(ex, "reportSupressedException");
+        }
+    }
+}
diff --git a/test-app/build-tools/android-dts-generator b/test-app/build-tools/android-dts-generator
index cce79ede4..32ad4e004 160000
--- a/test-app/build-tools/android-dts-generator
+++ b/test-app/build-tools/android-dts-generator
@@ -1 +1 @@
-Subproject commit cce79ede41dee84aee7e967dc5326a0e2d00f359
+Subproject commit 32ad4e0042e4af4a86761734b001ec7022f6135f
diff --git a/test-app/build-tools/android-metadata-generator/build.gradle b/test-app/build-tools/android-metadata-generator/build.gradle
index 9bcb52ff5..c2df40ad3 100644
--- a/test-app/build-tools/android-metadata-generator/build.gradle
+++ b/test-app/build-tools/android-metadata-generator/build.gradle
@@ -17,7 +17,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.1'
+        classpath 'com.android.tools.build:gradle:3.3.0'
     }
 }
 
@@ -36,7 +36,7 @@ compileJava {
 compileJava.outputs.dir("$rootDir/dist/classes")
 
 dependencies {
-    compile 'org.apache.bcel:bcel:6.0'
+    compile 'org.apache.bcel:bcel:6.2'
     compile files("./src/libs/dx.jar")
 }
 
diff --git a/test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/bcl/ClassInfo.java b/test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/bcl/ClassInfo.java
index 6082ac788..af70c1e09 100644
--- a/test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/bcl/ClassInfo.java
+++ b/test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/bcl/ClassInfo.java
@@ -7,6 +7,8 @@
 import com.telerik.metadata.desc.MethodDescriptor;
 
 import org.apache.bcel.classfile.Attribute;
+import org.apache.bcel.classfile.ConstantClass;
+import org.apache.bcel.classfile.ConstantPool;
 import org.apache.bcel.classfile.ConstantUtf8;
 import org.apache.bcel.classfile.Field;
 import org.apache.bcel.classfile.InnerClass;
@@ -36,19 +38,18 @@ private void init() {
                 return;
             }
             boolean found = false;
+            String fullClassName = getClassName(clazz.getClassNameIndex());
+            if (fullClassName == null) {
+                return;
+            }
+
             for (Attribute a : clazz.getAttributes()) {
                 if (a instanceof InnerClasses) {
                     InnerClass[] i = ((InnerClasses) a).getInnerClasses();
                     for (InnerClass ic : i) {
+                        String innerClassName = getClassName(ic.getInnerClassIndex());
 
-                        ConstantUtf8 cname = (ConstantUtf8) clazz
-                                             .getConstantPool().getConstant(ic.getInnerNameIndex());
-                        if (cname == null) {
-                            continue;
-                        }
-
-                        String innerClassname = cname.getBytes();
-                        if (name.equals(innerClassname)) {
+                        if (fullClassName.equals(innerClassName)) {
                             int flags = ic.getInnerAccessFlags();
                             clazz.setAccessFlags(flags);
                             found = true;
@@ -63,6 +64,19 @@ private void init() {
         }
     }
 
+    private String getClassName(int classIndex) {
+        ConstantPool constantPool = clazz.getConstantPool();
+        ConstantClass innerClassNameIndex = (ConstantClass)constantPool.getConstant(classIndex);
+        if (innerClassNameIndex == null) {
+            return null;
+        }
+        ConstantUtf8 className = (ConstantUtf8)constantPool.getConstant(innerClassNameIndex.getNameIndex());
+        if (className == null) {
+            return null;
+        }
+        return className.getBytes();
+    }
+
     @Override
     public boolean isClass() {
         return clazz.isClass();
diff --git a/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity.android.ts b/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity.android.ts
index b577da7d1..a8a6ba239 100644
--- a/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity.android.ts
+++ b/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity.android.ts
@@ -1,7 +1,7 @@
 import Bundle = android.os.Bundle;
 
 @JavaProxy('org.nativescript.MyCustomActivity')
-export class TestActivity extends android.app.Activity {
+export class TestActivity extends android.support.v7.app.AppCompatActivity {
     static readonly TEST1: string = "my_test";
     public onCreate(savedInstanceState?: Bundle): void {
         super.onCreate(savedInstanceState);
diff --git a/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity_ts.android.js b/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity_ts.android.js
index 48bf750fb..1206bc37a 100644
--- a/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity_ts.android.js
+++ b/test-app/build-tools/jsparser/tests/cases/decorated_double_assignment_ts/app/myCustomActivity_ts.android.js
@@ -16,5 +16,5 @@ var TestActivity = (function (_super) {
         JavaProxy('org.nativescript.MyCustomActivity')
     ], TestActivity);
     return TestActivity;
-}(android.app.Activity));
+}(android.support.v7.app.AppCompatActivity));
 exports.TestActivity = TestActivity;
\ No newline at end of file
diff --git a/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java b/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java
index 0527bf09e..31c833540 100644
--- a/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java
+++ b/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java
@@ -13,6 +13,7 @@
 import java.nio.file.Paths;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -39,14 +40,14 @@ public class Generator {
     private static final String LINE_SEPARATOR = System.getProperty("line.separator");
 
     private static final String AUTO_GENERATED_FILE_PROLOGUE =
-        "/* AUTO-GENERATED FILE. DO NOT MODIFY." + LINE_SEPARATOR +
-        " * This class was automatically generated by the" + LINE_SEPARATOR +
-        " * static binding generator from the resources it found." + LINE_SEPARATOR +
-        " * Please do not modify by hand." + LINE_SEPARATOR +
-        " */" + LINE_SEPARATOR;
+            "/* AUTO-GENERATED FILE. DO NOT MODIFY." + LINE_SEPARATOR +
+                    " * This class was automatically generated by the" + LINE_SEPARATOR +
+                    " * static binding generator from the resources it found." + LINE_SEPARATOR +
+                    " * Please do not modify by hand." + LINE_SEPARATOR +
+                    " */" + LINE_SEPARATOR;
 
     private final File outputDir;
-    private final List<DataRow>  libs;
+    private final List<DataRow> libs;
     private final Map<String, JavaClass> classes;
     private final boolean suppressCallJSMethodExceptions;
 
@@ -212,7 +213,7 @@ private String getNormalizedName(String filename) {
         return sb.toString();
     }
 
-    private Map<String, MethodGroup> getPublicApi(JavaClass clazz) throws ClassNotFoundException {
+    private Map<String, MethodGroup> getPublicApi(JavaClass clazz, List<String> userImplementedInterfacesNames) throws ClassNotFoundException {
         Map<String, MethodGroup> api = new HashMap<String, MethodGroup>();
         JavaClass currentClass = clazz;
         String clazzName = clazz.getClassName();
@@ -224,7 +225,7 @@ private Map<String, MethodGroup> getPublicApi(JavaClass clazz) throws ClassNotFo
                 methods.add(m);
             }
 
-            collectInterfaceMethods(clazz, methods);
+            collectInterfaceMethods(clazz, userImplementedInterfacesNames, methods);
             for (Method m : methods) {
                 if (!m.isSynthetic() && (m.isPublic() || m.isProtected()) && !m.isStatic()) {
                     String name = m.getName();
@@ -302,7 +303,7 @@ private Map<String, JavaClass> readDir(String path, boolean throwOnError) throws
         while (!d.isEmpty()) {
             File cur = d.pollFirst();
             File[] files = cur.listFiles();
-            for (File f: files) {
+            for (File f : files) {
                 if (f.isFile() && f.getName().endsWith(CLASS_EXT)) {
                     ClassParser cp = new ClassParser(f.getAbsolutePath());
                     JavaClass clazz = cp.parse();
@@ -337,9 +338,8 @@ private String getFullMethodSignature(Method m) {
 
     private void writeBinding(Writer w, DataRow dataRow, JavaClass clazz, String packageName, String name) throws ClassNotFoundException {
         String[] implInterfaces = dataRow.getInterfaces();
-        collectImplementedInterfaces(implInterfaces, clazz);
 
-        Map<String, MethodGroup> api = getPublicApi(clazz);
+        Map<String, MethodGroup> api = getPublicApi(clazz, Arrays.asList(dataRow.getInterfaces()));
 
         w.writeln("package " + packageName + ";");
         w.writeln();
@@ -403,7 +403,7 @@ private void writeBinding(Writer w, DataRow dataRow, JavaClass clazz, String pac
             }
             Set<Method> notImplementedObjectMethods = new HashSet<Method>();
             Method[] currentIfaceMethods = clazz.getMethods();
-            ArrayList<Method> ifaceMethods = new ArrayList<Method>();
+            Set<Method> ifaceMethods = new HashSet<>();
             for (Method m : currentIfaceMethods) {
                 if (!m.getName().equals("<clinit>")) {
                     ifaceMethods.add(m);
@@ -445,7 +445,7 @@ private void writeBinding(Writer w, DataRow dataRow, JavaClass clazz, String pac
             }
         } else {
             List<Method> interfaceMethods = new ArrayList<Method>();
-            collectInterfaceMethods(clazz, interfaceMethods);
+            collectInterfaceMethods(clazz, Arrays.asList(dataRow.getInterfaces()), interfaceMethods);
             for (String methodName : dataRow.getMethods()) {
                 if (api.containsKey(methodName)) {
                     List<Method> methodGroup = api.get(methodName).getList();
@@ -480,8 +480,8 @@ private void writeBinding(Writer w, DataRow dataRow, JavaClass clazz, String pac
     private boolean isClassApplication(JavaClass clazz) {
         String className = clazz.getClassName();
         return className.equals("android.app.Application") ||
-               className.equals("android.support.multidex.MultiDexApplication") ||
-               className.equals("android.test.mock.MockApplication");
+                className.equals("android.support.multidex.MultiDexApplication") ||
+                className.equals("android.test.mock.MockApplication");
     }
 
     private void writeMethodBody(Method m, Writer w, boolean isApplicationClass, boolean isActivityClass, boolean isInterfaceMethod) {
@@ -642,7 +642,7 @@ private void writeMethodBody(Method m, boolean isConstructor, boolean isApplicat
         w.write("\t\t");
         Type ret = m.getReturnType();
 
-        if(this.suppressCallJSMethodExceptions) {
+        if (this.suppressCallJSMethodExceptions) {
             w.writeln("try {");
             w.write("\t\t\t");
         }
@@ -658,9 +658,10 @@ private void writeMethodBody(Method m, boolean isConstructor, boolean isApplicat
         writeType(ret, w);
         w.writeln(".class, args);");
 
-        if(this.suppressCallJSMethodExceptions) {
+        if (this.suppressCallJSMethodExceptions) {
             w.writeln("\t\t} catch (Throwable t) {");
-            w.writeln("\t\t\tandroid.util.Log.w(\"Error\", t);");
+            w.writeln("\t\t\tcom.tns.Runtime.passSuppressedExceptionToJs(t, \"" + m.getName() + "\");");
+            w.writeln("\t\t\tandroid.util.Log.w(\"Warning\", \"NativeScript discarding uncaught JS exception!\");");
             if (!ret.equals(Type.VOID)) {
                 w.write("\t\t\t");
                 w.write("return ");
@@ -687,7 +688,7 @@ private void writeType(Type t, Writer w) {
         w.write(type);
     }
 
-    private void collectInterfaceMethods(JavaClass clazz, List<Method> methods) throws ClassNotFoundException {
+    private void collectInterfaceMethods(JavaClass clazz, List<String> userImplementedInterfacesNames, List<Method> methods) throws ClassNotFoundException {
         JavaClass currentClass = clazz;
 
         while (true) {
@@ -698,6 +699,12 @@ private void collectInterfaceMethods(JavaClass clazz, List<Method> methods) thro
                 queue.add(name);
             }
 
+            for (String userImplementedInterfaceName : userImplementedInterfacesNames) {
+                if (userImplementedInterfaceName != null && !userImplementedInterfaceName.equals("")) {
+                    queue.add(userImplementedInterfaceName);
+                }
+            }
+
             while (!queue.isEmpty()) {
                 String ifaceName = queue.poll();
                 JavaClass currentInterface = getClass(ifaceName);
@@ -747,15 +754,17 @@ private boolean isApplicationClass(JavaClass clazz, Map<String, JavaClass> class
     private boolean isActivityClass(JavaClass clazz, Map<String, JavaClass> classes) throws ClassNotFoundException {
         boolean isActivityClass = false;
 
-        String activityClassname = "android.app.Activity";
+        List<String> activityClassNames = Arrays.asList("android.app.Activity", "android.support.v7.app.AppCompatActivity", "androidx.appcompat.app.AppCompatActivity");
 
         JavaClass currentClass = clazz;
         while (true) {
             String currentClassname = currentClass.getClassName();
 
-            isActivityClass = currentClassname.equals(activityClassname);
-            if (isActivityClass) {
-                break;
+            for (String activityClassName : activityClassNames) {
+                isActivityClass = currentClassname.equals(activityClassName);
+                if (isActivityClass) {
+                    return true;
+                }
             }
 
             if (currentClassname.endsWith("java.lang.Object")) {
@@ -822,7 +831,7 @@ private void cleanPreviouslyAutoGeneratedFiles(File folder) {
         // some javascript files containing native extends are removed,
         // their corresponding java classes will also be removed.
         File[] files = folder.listFiles();
-        for (File file: files) {
+        for (File file : files) {
             if (file.isDirectory()) {
                 this.cleanPreviouslyAutoGeneratedFiles(file);
             } else if ("java".equalsIgnoreCase(this.getFileExtension(file.toString()))) {
@@ -865,4 +874,4 @@ private String readFile(File file) {
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/test-app/build.gradle b/test-app/build.gradle
index 56dc9966f..1d1846917 100644
--- a/test-app/build.gradle
+++ b/test-app/build.gradle
@@ -7,7 +7,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.1'
+        classpath 'com.android.tools.build:gradle:3.3.0'
     }
 }
 
diff --git a/test-app/gradle.properties b/test-app/gradle.properties
index aac7c9b46..a0b287cbb 100644
--- a/test-app/gradle.properties
+++ b/test-app/gradle.properties
@@ -9,6 +9,8 @@
 
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
+# android.enableJetifier=true
+android.useAndroidX=true
 org.gradle.jvmargs=-Xmx1536m
 
 # When configured, Gradle will run in incubating parallel mode.
diff --git a/test-app/runtests.gradle b/test-app/runtests.gradle
index 096053de2..cddedd83e 100644
--- a/test-app/runtests.gradle
+++ b/test-app/runtests.gradle
@@ -1,6 +1,6 @@
 def isWinOs = System.properties['os.name'].toLowerCase().contains('windows')
-def runOnDevice = project.hasProperty("runOnDevice");
-def runOnDeviceOrEmulator = runOnDevice ? "-d" : "-e";
+def runOnDevice = project.hasProperty("runOnDevice")
+def runOnDeviceOrEmulator = runOnDevice ? "-d" : "-e"
 
 def onlyX86 = project.hasProperty("onlyX86")
 def useCCache = project.hasProperty("useCCache")
@@ -37,7 +37,7 @@ def getBuildArguments = { ->
     if (useCCache) {
         arguments.push("-PuseCCache")
     }
-    return arguments;
+    return arguments
 }
 
 task installApk(type: Exec) {
diff --git a/test-app/runtime/build.gradle b/test-app/runtime/build.gradle
index b9ce2782f..80336ce4c 100644
--- a/test-app/runtime/build.gradle
+++ b/test-app/runtime/build.gradle
@@ -32,7 +32,7 @@ android {
             java.srcDirs = [bindingGeneratorSourcePath, defaultSrcPath]
         }
     }
-    compileSdkVersion 26
+    compileSdkVersion 28
     buildToolsVersion project.ext._buildToolsVersion
 
     defaultConfig {
@@ -61,7 +61,7 @@ android {
                     arguments.push("-DOPTIMIZED_WITH_INSPECTOR_BUILD=true")
                 }
 
-                if(useCCache) {
+                if (useCCache) {
                     arguments.push("-DUSE_CCACHE=true")
                 }
 
@@ -104,6 +104,8 @@ allprojects {
 
 dependencies {
     implementation fileTree(include: ['*.jar'], dir: 'libs')
+    testImplementation 'junit:junit:4.12'
+    testImplementation 'org.mockito:mockito-core:1.10.19'
 }
 
 tasks.whenTaskAdded { task ->
@@ -112,6 +114,11 @@ tasks.whenTaskAdded { task ->
         setRuntimeCommit.dependsOn(setPackageVersion)
         task.dependsOn(setRuntimeCommit)
     }
+
+    if(taskName.contains("bundleReleaseAar")){
+        task.dependsOn("testDebugUnitTest")
+    }
+
     if (taskName.contains("Strip")) {
         task.finalizedBy(revertVersionFile)
     }
diff --git a/test-app/runtime/src/main/cpp/ArgConverter.cpp b/test-app/runtime/src/main/cpp/ArgConverter.cpp
index 3c12f5e97..168d3f068 100644
--- a/test-app/runtime/src/main/cpp/ArgConverter.cpp
+++ b/test-app/runtime/src/main/cpp/ArgConverter.cpp
@@ -216,7 +216,7 @@ int64_t ArgConverter::ConvertToJavaLong(Isolate* isolate, const Local<Value>& va
 
     assert(!valueProp.IsEmpty());
 
-    string num = ConvertToString(valueProp->ToString());
+    string num = ConvertToString(valueProp->ToString(isolate));
 
     int64_t longValue = atoll(num.c_str());
 
@@ -241,7 +241,8 @@ string ArgConverter::ConvertToString(const v8::Local<String>& s) {
     if (s.IsEmpty()) {
         return string();
     } else {
-        String::Utf8Value str(s);
+        auto isolate = v8::Isolate::GetCurrent();
+        String::Utf8Value str(isolate, s);
         return string(*str);
     }
 }
@@ -259,7 +260,8 @@ u16string ArgConverter::ConvertToUtf16String(const v8::Local<String>& s) {
 
 jstring ArgConverter::ConvertToJavaString(const Local<Value>& value) {
     JEnv env;
-    String::Value stringValue(value);
+    auto isolate = v8::Isolate::GetCurrent();
+    String::Value stringValue(isolate, value);
     return env.NewString((const jchar*) *stringValue, stringValue.length());
 }
 
@@ -276,18 +278,8 @@ Local<String> ArgConverter::ConvertToV8String(Isolate* isolate, const char* data
     return String::NewFromUtf8(isolate, (const char*) data, String::kNormalString, length);
 }
 
-Local<String> ArgConverter::ConvertToV8UTF16String(Isolate* isolate, const string& string) {
-    auto utf16str = Util::ConvertFromUtf8ToUtf16(string);
-
-    return ConvertToV8UTF16String(isolate, utf16str);
-}
-
 Local<String> ArgConverter::ConvertToV8UTF16String(Isolate* isolate, const u16string& utf16string) {
     return String::NewFromTwoByte(isolate, ((const uint16_t*) utf16string.data()));
 }
 
-Local<String> ArgConverter::ConvertToV8UTF16String(v8::Isolate* isolate, const uint16_t* utf16string, int size) {
-    return String::NewFromTwoByte(isolate, utf16string, NewStringType::kNormal, size).ToLocalChecked();
-}
-
 std::map<Isolate*, ArgConverter::TypeLongOperationsCache*> ArgConverter::s_type_long_operations_cache;
\ No newline at end of file
diff --git a/test-app/runtime/src/main/cpp/ArgConverter.h b/test-app/runtime/src/main/cpp/ArgConverter.h
index a7d439296..6ebbf2a6a 100644
--- a/test-app/runtime/src/main/cpp/ArgConverter.h
+++ b/test-app/runtime/src/main/cpp/ArgConverter.h
@@ -40,10 +40,6 @@ class ArgConverter {
 
         static v8::Local<v8::String> ConvertToV8String(v8::Isolate* isolate, const char* data, int length);
 
-        static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const std::string& string);
-
-        static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const uint16_t* utf16string, int size);
-
         static v8::Local<v8::String> ConvertToV8UTF16String(v8::Isolate* isolate, const std::u16string& utf16string);
 
     private:
diff --git a/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp b/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp
index a81957a53..221a29c51 100644
--- a/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp
+++ b/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp
@@ -83,6 +83,7 @@ void ArrayElementAccessor::SetArrayElement(Isolate* isolate, const Local<Object>
     HandleScope handleScope(isolate);
     auto runtime = Runtime::GetRuntime(isolate);
     auto objectManager = runtime->GetObjectManager();
+    auto context = isolate->GetCurrentContext();
 
     auto arr = objectManager->GetJavaObjectByJsObject(array);
 
@@ -90,15 +91,15 @@ void ArrayElementAccessor::SetArrayElement(Isolate* isolate, const Local<Object>
     jboolean isCopy = false;
 
     if (elementSignature == "Z") { //bool
-        jboolean boolElementValue = (jboolean) value->BooleanValue();
+        jboolean boolElementValue = (jboolean) value->BooleanValue(context).ToChecked();
         jbooleanArray boolArr = static_cast<jbooleanArray>(arr);
         env.SetBooleanArrayRegion(boolArr, index, 1, &boolElementValue);
     } else if (elementSignature == "B") { //byte
-        jbyte byteElementValue = (jbyte) value->Int32Value();
+        jbyte byteElementValue = (jbyte) value->Int32Value(context).ToChecked();
         jbyteArray byteArr = static_cast<jbyteArray>(arr);
         env.SetByteArrayRegion(byteArr, index, 1, &byteElementValue);
     } else if (elementSignature == "C") { //char
-        String::Utf8Value utf8(value->ToString());
+        String::Utf8Value utf8(isolate, value->ToString(isolate));
         JniLocalRef s(env.NewString((jchar*) *utf8, 1));
         const char* singleChar = env.GetStringUTFChars(s, &isCopy);
         jchar charElementValue = *singleChar;
@@ -106,11 +107,11 @@ void ArrayElementAccessor::SetArrayElement(Isolate* isolate, const Local<Object>
         jcharArray charArr = static_cast<jcharArray>(arr);
         env.SetCharArrayRegion(charArr, index, 1, &charElementValue);
     } else if (elementSignature == "S") { //short
-        jshort shortElementValue = (jshort) value->Int32Value();
+        jshort shortElementValue = (jshort) value->Int32Value(context).ToChecked();
         jshortArray shortArr = static_cast<jshortArray>(arr);
         env.SetShortArrayRegion(shortArr, index, 1, &shortElementValue);
     } else if (elementSignature == "I") { //int
-        jint intElementValue = value->Int32Value();
+        jint intElementValue = value->Int32Value(context).ToChecked();
         jintArray intArr = static_cast<jintArray>(arr);
         env.SetIntArrayRegion(intArr, index, 1, &intElementValue);
     } else if (elementSignature == "J") { //long
@@ -118,16 +119,16 @@ void ArrayElementAccessor::SetArrayElement(Isolate* isolate, const Local<Object>
         if (value->IsObject()) {
             longElementValue = (jlong) ArgConverter::ConvertToJavaLong(isolate, value);
         } else {
-            longElementValue = (jlong) value->IntegerValue();
+            longElementValue = (jlong) value->IntegerValue(context).ToChecked();
         }
         jlongArray longArr = static_cast<jlongArray>(arr);
         env.SetLongArrayRegion(longArr, index, 1, &longElementValue);
     } else if (elementSignature == "F") { //float
-        jfloat floatElementValue = (jfloat) value->NumberValue();
+        jfloat floatElementValue = (jfloat) value->NumberValue(context).ToChecked();
         jfloatArray floatArr = static_cast<jfloatArray>(arr);
         env.SetFloatArrayRegion(floatArr, index, 1, &floatElementValue);
     } else if (elementSignature == "D") { //double
-        jdouble doubleElementValue = (jdouble) value->NumberValue();
+        jdouble doubleElementValue = (jdouble) value->NumberValue(context).ToChecked();
         jdoubleArray doubleArr = static_cast<jdoubleArray>(arr);
         env.SetDoubleArrayRegion(doubleArr, index, 1, &doubleElementValue);
     } else { //string or object
diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp
index f1fbb6ffc..318ab6590 100644
--- a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp
+++ b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp
@@ -559,6 +559,7 @@ CallbackHandlers::GetImplementedInterfaces(JEnv &env, const Local<Object> &imple
 
     vector<jstring> interfacesToImplement;
     auto propNames = implementationObject->GetOwnPropertyNames();
+    auto isolate = implementationObject->GetIsolate();
     for (int i = 0; i < propNames->Length(); i++) {
         auto name = propNames->Get(i).As<String>();
         auto prop = implementationObject->Get(name);
@@ -566,14 +567,15 @@ CallbackHandlers::GetImplementedInterfaces(JEnv &env, const Local<Object> &imple
         bool arrFound = !prop.IsEmpty() && prop->IsArray();
 
         if (arrFound) {
-            v8::String::Utf8Value propName(name);
+            v8::String::Utf8Value propName(isolate, name);
             std::string arrNameC = std::string(*propName);
             if (arrNameC == "interfaces") {
-                auto interfacesArr = prop->ToObject();
+                auto interfacesArr = prop->ToObject(isolate);
 
-                auto isolate = implementationObject->GetIsolate();
+                auto context = isolate->GetCurrentContext();
                 int length = interfacesArr->Get(
-                        v8::String::NewFromUtf8(isolate, "length"))->ToObject()->Uint32Value();
+                        v8::String::NewFromUtf8(isolate, "length"))->ToObject(isolate)->Uint32Value(
+                        context).ToChecked();
 
                 if (length > 0) {
                     for (int i = 0; i < length; i++) {
@@ -615,6 +617,7 @@ CallbackHandlers::GetMethodOverrides(JEnv &env, const Local<Object> &implementat
 
     vector<jstring> methodNames;
     auto propNames = implementationObject->GetOwnPropertyNames();
+    auto isolate = implementationObject->GetIsolate();
     for (int i = 0; i < propNames->Length(); i++) {
         auto name = propNames->Get(i).As<String>();
         auto method = implementationObject->Get(name);
@@ -622,7 +625,7 @@ CallbackHandlers::GetMethodOverrides(JEnv &env, const Local<Object> &implementat
         bool methodFound = !method.IsEmpty() && method->IsFunction();
 
         if (methodFound) {
-            String::Utf8Value stringValue(name);
+            String::Utf8Value stringValue(isolate, name);
             jstring value = env.NewStringUTF(*stringValue);
             methodNames.push_back(value);
         }
@@ -645,7 +648,8 @@ CallbackHandlers::GetMethodOverrides(JEnv &env, const Local<Object> &implementat
 void CallbackHandlers::LogMethodCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
     try {
         if ((args.Length() > 0) && args[0]->IsString()) {
-            String::Utf8Value message(args[0]->ToString());
+            auto isolate = args.GetIsolate();
+            String::Utf8Value message(isolate, args[0]->ToString(isolate));
             DEBUG_WRITE("%s", *message);
         }
     } catch (NativeScriptException &e) {
@@ -668,6 +672,38 @@ void CallbackHandlers::TimeCallback(const v8::FunctionCallbackInfo<v8::Value> &a
     args.GetReturnValue().Set(duration);
 }
 
+void CallbackHandlers::ReleaseNativeCounterpartCallback(
+        const v8::FunctionCallbackInfo<v8::Value> &info) {
+    try {
+        SET_PROFILER_FRAME();
+
+        validateProvidedArgumentsLength(info, 1);
+
+        auto isolate = info.GetIsolate();
+        Handle<Object> obj = info[0].As<Object>();
+
+        auto runtime = Runtime::GetRuntime(isolate);
+        auto objectManager = runtime->GetObjectManager();
+        objectManager->ReleaseNativeCounterpart(obj);
+    } catch (NativeScriptException &e) {
+        e.ReThrowToV8();
+    } catch (std::exception e) {
+        stringstream ss;
+        ss << "Error: c++ exception: " << e.what() << endl;
+        NativeScriptException nsEx(ss.str());
+        nsEx.ReThrowToV8();
+    } catch (...) {
+        NativeScriptException nsEx(std::string("Error: c++ exception!"));
+        nsEx.ReThrowToV8();
+    }
+}
+
+void CallbackHandlers::validateProvidedArgumentsLength(const v8::FunctionCallbackInfo<v8::Value> &args, int expectedSize) {
+    if(args.Length() != expectedSize){
+        throw NativeScriptException("Unexpected arguments count!");
+    }
+}
+
 void CallbackHandlers::DumpReferenceTablesMethodCallback(
         const v8::FunctionCallbackInfo<v8::Value> &args) {
     DumpReferenceTablesMethod();
@@ -887,7 +923,7 @@ void CallbackHandlers::NewThreadCallback(const v8::FunctionCallbackInfo<v8::Valu
 
         auto currentExecutingScriptName = StackTrace::CurrentStackTrace(isolate, 1,
                                                                         StackTrace::kScriptName)->GetFrame(
-                0)->GetScriptName();
+                isolate, 0)->GetScriptName();
         auto currentExecutingScriptNameStr = ArgConverter::ConvertToString(
                 currentExecutingScriptName);
         auto lastForwardSlash = currentExecutingScriptNameStr.find_last_of("/");
@@ -952,9 +988,10 @@ CallbackHandlers::WorkerObjectPostMessageCallback(const v8::FunctionCallbackInfo
                                            ArgConverter::ConvertToV8String(isolate, "workerId"),
                                            jsId);
 
-        Local<String> msg = tns::JsonStringifyObject(isolate, args[0])->ToString();
+        Local<String> msg = tns::JsonStringifyObject(isolate, args[0])->ToString(isolate);
+        auto context = isolate->GetCurrentContext();
         // get worker's ID that is associated on the other side - in Java
-        auto id = jsId->Int32Value();
+        auto id = jsId->Int32Value(context).ToChecked();
 
         JEnv env;
         auto mId = env.GetStaticMethodID(RUNTIME_CLASS, "sendMessageFromMainToWorker",
@@ -1049,7 +1086,7 @@ CallbackHandlers::WorkerGlobalPostMessageCallback(const v8::FunctionCallbackInfo
             return;
         }
 
-        Local<String> msg = tns::JsonStringifyObject(isolate, args[0])->ToString();
+        Local<String> msg = tns::JsonStringifyObject(isolate, args[0])->ToString(isolate);
 
         JEnv env;
         auto mId = env.GetStaticMethodID(RUNTIME_CLASS, "sendMessageFromWorkerToMain",
@@ -1145,6 +1182,7 @@ CallbackHandlers::WorkerObjectTerminateCallback(const v8::FunctionCallbackInfo<v
         HandleScope scope(isolate);
 
         auto thiz = args.This(); // Worker instance
+        auto context = isolate->GetCurrentContext();
 
         Local<Value> jsId;
 
@@ -1153,13 +1191,13 @@ CallbackHandlers::WorkerObjectTerminateCallback(const v8::FunctionCallbackInfo<v
                                            jsId);
 
         // get worker's ID that is associated on the other side - in Java
-        auto id = jsId->Int32Value();
+        auto id = jsId->Int32Value(context).ToChecked();
 
         Local<Value> isTerminated;
         V8GetPrivateValue(isolate, thiz, ArgConverter::ConvertToV8String(isolate, "isTerminated"),
                           isTerminated);
 
-        if (!isTerminated.IsEmpty() && isTerminated->BooleanValue()) {
+        if (!isTerminated.IsEmpty() && isTerminated->BooleanValue(context).ToChecked()) {
             DEBUG_WRITE(
                     "Main: WorkerObjectTerminateCallback - Worker(id=%d)'s terminate has already been called.",
                     id);
@@ -1204,7 +1242,7 @@ void CallbackHandlers::WorkerGlobalCloseCallback(const v8::FunctionCallbackInfo<
         auto isTerminating = globalObject->Get(
                 ArgConverter::ConvertToV8String(isolate, "isTerminating"));
 
-        if (!isTerminating.IsEmpty() && isTerminating->BooleanValue()) {
+        if (!isTerminating.IsEmpty() && isTerminating->BooleanValue(context).ToChecked()) {
             DEBUG_WRITE("WORKER: WorkerThreadCloseCallback - Worker is currently terminating...");
             return;
         }
@@ -1273,7 +1311,7 @@ void CallbackHandlers::CallWorkerScopeOnErrorHandle(Isolate *isolate, TryCatch &
             auto result = func->Call(Undefined(isolate), 1, args1);
 
             // return 'true'-like value, don't bubble up to main Worker.onerror
-            if (!result.IsEmpty() && result->BooleanValue()) {
+            if (!result.IsEmpty() && result->BooleanValue(context).ToChecked()) {
                 // Do nothing, exception has been handled
                 return;
             }
@@ -1281,7 +1319,7 @@ void CallbackHandlers::CallWorkerScopeOnErrorHandle(Isolate *isolate, TryCatch &
 
         // will account for exceptions thrown inside the error handler
         if (innerTc.HasCaught()) {
-            auto lno = innerTc.Message()->GetLineNumber();
+            auto lno = innerTc.Message()->GetLineNumber(context).ToChecked();
             auto msg = innerTc.Message()->Get();
             Local<Value> outStackTrace = innerTc.StackTrace(context).FromMaybe(Local<Value>());
             Local<String> stackTrace;
@@ -1295,7 +1333,7 @@ void CallbackHandlers::CallWorkerScopeOnErrorHandle(Isolate *isolate, TryCatch &
         }
 
         // throw so that it may bubble up to main
-        auto lno = tc.Message()->GetLineNumber();
+        auto lno = tc.Message()->GetLineNumber(context).ToChecked();
         auto msg = tc.Message()->Get();
         auto source = tc.Message()->GetScriptResourceName()->ToString(isolate);
         Local<Value> outStackTrace = tc.StackTrace(context).FromMaybe(Local<Value>());
@@ -1367,7 +1405,8 @@ CallbackHandlers::CallWorkerObjectOnErrorHandle(Isolate *isolate, jint workerId,
 
             // Handle exceptions thrown in onmessage with the worker.onerror handler, if present
             auto result = func->Call(Undefined(isolate), 1, args1);
-            if (!result.IsEmpty() && result->BooleanValue()) {
+            auto context = isolate->GetCurrentContext();
+            if (!result.IsEmpty() && result->BooleanValue(context).ToChecked()) {
                 // Do nothing, exception is handled and does not need to be raised to application level
                 return;
             }
@@ -1442,6 +1481,8 @@ jmethodID CallbackHandlers::ENABLE_VERBOSE_LOGGING_METHOD_ID = nullptr;
 jmethodID CallbackHandlers::DISABLE_VERBOSE_LOGGING_METHOD_ID = nullptr;
 jmethodID CallbackHandlers::INIT_WORKER_METHOD_ID = nullptr;
 
+
+
 NumericCasts CallbackHandlers::castFunctions;
 ArrayElementAccessor CallbackHandlers::arrayElementAccessor;
 FieldAccessor CallbackHandlers::fieldAccessor;
diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.h b/test-app/runtime/src/main/cpp/CallbackHandlers.h
index 72fb2567b..ebf8ca9e1 100644
--- a/test-app/runtime/src/main/cpp/CallbackHandlers.h
+++ b/test-app/runtime/src/main/cpp/CallbackHandlers.h
@@ -111,6 +111,8 @@ namespace tns {
         static void
         DisableVerboseLoggingMethodCallback(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+        static void ReleaseNativeCounterpartCallback(const v8::FunctionCallbackInfo<v8::Value> &info);
+
         static v8::Local<v8::Object> FindClass(v8::Isolate *isolate, const std::string &className);
 
         static void NewThreadCallback(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -194,6 +196,8 @@ namespace tns {
          */
         static jobjectArray GetJavaStringArray(JEnv &env, int length);
 
+        static void validateProvidedArgumentsLength(const v8::FunctionCallbackInfo<v8::Value> &args, int expectedSize);
+
         static short MAX_JAVA_STRING_ARRAY_LENGTH;
 
         static jclass RUNTIME_CLASS;
@@ -235,6 +239,8 @@ namespace tns {
             jfieldID _fieldID;
             jobject _runtime;
         };
+
+
     };
 }
 
diff --git a/test-app/runtime/src/main/cpp/DOMDomainCallbackHandlers.cpp b/test-app/runtime/src/main/cpp/DOMDomainCallbackHandlers.cpp
index ec075f30c..f73e2789d 100644
--- a/test-app/runtime/src/main/cpp/DOMDomainCallbackHandlers.cpp
+++ b/test-app/runtime/src/main/cpp/DOMDomainCallbackHandlers.cpp
@@ -54,7 +54,8 @@ void DOMDomainCallbackHandlers::ChildNodeInsertedCallback(const v8::FunctionCall
             return;
         }
 
-        domAgentInstance->m_frontend.childNodeInserted(parentId->Int32Value(), lastId->Int32Value(), std::move(domNode));
+        auto context = isolate->GetCurrentContext();
+        domAgentInstance->m_frontend.childNodeInserted(parentId->Int32Value(context).ToChecked(), lastId->Int32Value(context).ToChecked(), std::move(domNode));
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
@@ -87,7 +88,8 @@ void DOMDomainCallbackHandlers::ChildNodeRemovedCallback(const v8::FunctionCallb
         auto parentId = args[0]->ToNumber(isolate);
         auto nodeId = args[1]->ToNumber(isolate);
 
-        domAgentInstance->m_frontend.childNodeRemoved(parentId->Int32Value(), nodeId->Int32Value());
+        auto context = isolate->GetCurrentContext();
+        domAgentInstance->m_frontend.childNodeRemoved(parentId->Int32Value(context).ToChecked(), nodeId->Int32Value(context).ToChecked());
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
@@ -118,12 +120,13 @@ void DOMDomainCallbackHandlers::AttributeModifiedCallback(const v8::FunctionCall
         }
 
         auto nodeId = args[0]->ToNumber(isolate);
-        auto attributeName = args[1]->ToString();
-        auto attributeValue = args[2]->ToString();
+        auto attributeName = args[1]->ToString(isolate);
+        auto attributeValue = args[2]->ToString(isolate);
 
-        domAgentInstance->m_frontend.attributeModified(nodeId->Int32Value(),
-                v8_inspector::toProtocolString(attributeName),
-                v8_inspector::toProtocolString(attributeValue));
+        auto context = isolate->GetCurrentContext();
+        domAgentInstance->m_frontend.attributeModified(nodeId->Int32Value(context).ToChecked(),
+                v8_inspector::toProtocolString(isolate, attributeName),
+                v8_inspector::toProtocolString(isolate, attributeValue));
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
@@ -153,10 +156,11 @@ void DOMDomainCallbackHandlers::AttributeRemovedCallback(const v8::FunctionCallb
         }
 
         auto nodeId = args[0]->ToNumber(isolate);
-        auto attributeName = args[1]->ToString();
+        auto attributeName = args[1]->ToString(isolate);
 
-        domAgentInstance->m_frontend.attributeRemoved(nodeId->Int32Value(),
-                v8_inspector::toProtocolString(attributeName));
+        auto context = isolate->GetCurrentContext();
+        domAgentInstance->m_frontend.attributeRemoved(nodeId->Int32Value(context).ToChecked(),
+                v8_inspector::toProtocolString(isolate, attributeName));
     } catch (NativeScriptException& e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
diff --git a/test-app/runtime/src/main/cpp/FieldAccessor.cpp b/test-app/runtime/src/main/cpp/FieldAccessor.cpp
index 1757ece8e..fb9777d46 100644
--- a/test-app/runtime/src/main/cpp/FieldAccessor.cpp
+++ b/test-app/runtime/src/main/cpp/FieldAccessor.cpp
@@ -234,28 +234,29 @@ void FieldAccessor::SetJavaField(Isolate* isolate, const Local<Object>& target,
     auto clazz = fieldData->clazz;
 
     if (isPrimitiveType) {
+        auto context = isolate->GetCurrentContext();
         switch (fieldTypeName[0]) {
         case 'Z': { //bool
             //TODO: validate value is a boolean before calling
             if (isStatic) {
-                env.SetStaticBooleanField(clazz, fieldId, value->BooleanValue());
+                env.SetStaticBooleanField(clazz, fieldId, value->BooleanValue(context).ToChecked());
             } else {
-                env.SetBooleanField(targetJavaObject, fieldId, value->BooleanValue());
+                env.SetBooleanField(targetJavaObject, fieldId, value->BooleanValue(context).ToChecked());
             }
             break;
         }
         case 'B': { //byte
             //TODO: validate value is a byte before calling
             if (isStatic) {
-                env.SetStaticByteField(clazz, fieldId, value->Int32Value());
+                env.SetStaticByteField(clazz, fieldId, value->Int32Value(context).ToChecked());
             } else {
-                env.SetByteField(targetJavaObject, fieldId, value->Int32Value());
+                env.SetByteField(targetJavaObject, fieldId, value->Int32Value(context).ToChecked());
             }
             break;
         }
         case 'C': { //char
             //TODO: validate value is a single char
-            String::Utf8Value stringValue(value->ToString());
+            String::Utf8Value stringValue(isolate, value->ToString(isolate));
             JniLocalRef strValue(env.NewStringUTF(*stringValue));
             const char* chars = env.GetStringUTFChars(strValue, 0);
 
@@ -270,18 +271,18 @@ void FieldAccessor::SetJavaField(Isolate* isolate, const Local<Object>& target,
         case 'S': { //short
             //TODO: validate value is a short before calling
             if (isStatic) {
-                env.SetStaticShortField(clazz, fieldId, value->Int32Value());
+                env.SetStaticShortField(clazz, fieldId, value->Int32Value(context).ToChecked());
             } else {
-                env.SetShortField(targetJavaObject, fieldId, value->Int32Value());
+                env.SetShortField(targetJavaObject, fieldId, value->Int32Value(context).ToChecked());
             }
             break;
         }
         case 'I': { //int
             //TODO: validate value is a int before calling
             if (isStatic) {
-                env.SetStaticIntField(clazz, fieldId, value->Int32Value());
+                env.SetStaticIntField(clazz, fieldId, value->Int32Value(context).ToChecked());
             } else {
-                env.SetIntField(targetJavaObject, fieldId, value->Int32Value());
+                env.SetIntField(targetJavaObject, fieldId, value->Int32Value(context).ToChecked());
             }
             break;
 
@@ -297,17 +298,17 @@ void FieldAccessor::SetJavaField(Isolate* isolate, const Local<Object>& target,
         }
         case 'F': { //float
             if (isStatic) {
-                env.SetStaticFloatField(clazz, fieldId, static_cast<jfloat>(value->NumberValue()));
+                env.SetStaticFloatField(clazz, fieldId, static_cast<jfloat>(value->NumberValue(context).ToChecked()));
             } else {
-                env.SetFloatField(targetJavaObject, fieldId, static_cast<jfloat>(value->NumberValue()));
+                env.SetFloatField(targetJavaObject, fieldId, static_cast<jfloat>(value->NumberValue(context).ToChecked()));
             }
             break;
         }
         case 'D': { //double
             if (isStatic) {
-                env.SetStaticDoubleField(clazz, fieldId, value->NumberValue());
+                env.SetStaticDoubleField(clazz, fieldId, value->NumberValue(context).ToChecked());
             } else {
-                env.SetDoubleField(targetJavaObject, fieldId, value->NumberValue());
+                env.SetDoubleField(targetJavaObject, fieldId, value->NumberValue(context).ToChecked());
             }
             break;
         }
@@ -326,7 +327,7 @@ void FieldAccessor::SetJavaField(Isolate* isolate, const Local<Object>& target,
                 //TODO: validate valie is a string;
                 result = ArgConverter::ConvertToJavaString(value);
             } else {
-                auto objectWithHiddenID = value->ToObject();
+                auto objectWithHiddenID = value->ToObject(isolate);
                 result = objectManager->GetJavaObjectByJsObject(objectWithHiddenID);
             }
         }
diff --git a/test-app/runtime/src/main/cpp/JsArgConverter.cpp b/test-app/runtime/src/main/cpp/JsArgConverter.cpp
index 56fed5803..5a64a7cc3 100644
--- a/test-app/runtime/src/main/cpp/JsArgConverter.cpp
+++ b/test-app/runtime/src/main/cpp/JsArgConverter.cpp
@@ -98,7 +98,7 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
             sprintf(buff, "Cannot convert string to %s at index %d", typeSignature.c_str(), index);
         }
     } else if (arg->IsObject()) {
-        auto jsObject = arg->ToObject();
+        auto jsObject = arg->ToObject(m_isolate);
 
         auto castType = NumericCasts::GetCastType(m_isolate, jsObject);
 
@@ -107,12 +107,13 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
 
         auto runtime = Runtime::GetRuntime(m_isolate);
         auto objectManager = runtime->GetObjectManager();
+        auto context = m_isolate->GetCurrentContext();
 
         switch (castType) {
         case CastType::Char:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsString()) {
-                string value = ArgConverter::ConvertToString(castValue->ToString());
+                string value = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 m_args[index].c = (jchar) value[0];
                 success = true;
             }
@@ -121,12 +122,12 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
         case CastType::Byte:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsString()) {
-                string strValue = ArgConverter::ConvertToString(castValue->ToString());
+                string strValue = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 int byteArg = atoi(strValue.c_str());
                 jbyte value = (jbyte) byteArg;
                 success = ConvertFromCastFunctionObject(value, index);
             } else if (castValue->IsInt32()) {
-                jbyte value = (jbyte) castValue->ToInt32(m_isolate)->Int32Value();
+                jbyte value = (jbyte) castValue->ToInt32(m_isolate)->Int32Value(context).ToChecked();
                 success = ConvertFromCastFunctionObject(value, index);
             }
             break;
@@ -134,12 +135,12 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
         case CastType::Short:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsString()) {
-                string strValue = ArgConverter::ConvertToString(castValue->ToString());
+                string strValue = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 int shortArg = atoi(strValue.c_str());
                 jshort value = (jshort) shortArg;
                 success = ConvertFromCastFunctionObject(value, index);
             } else if (castValue->IsInt32()) {
-                jshort value = (jshort) castValue->ToInt32(m_isolate)->Int32Value();
+                jshort value = (jshort) castValue->ToInt32(m_isolate)->Int32Value(context).ToChecked();
                 success = ConvertFromCastFunctionObject(value, index);
             }
             break;
@@ -147,12 +148,12 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
         case CastType::Long:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsString()) {
-                string strValue = ArgConverter::ConvertToString(castValue->ToString());
+                string strValue = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 int64_t longArg = atoll(strValue.c_str());
                 jlong value = (jlong) longArg;
                 success = ConvertFromCastFunctionObject(value, index);
             } else if (castValue->IsInt32()) {
-                jlong value = (jlong) castValue->ToInt32(m_isolate)->IntegerValue();
+                jlong value = (jlong) castValue->ToInt32(m_isolate)->IntegerValue(context).ToChecked();
                 success = ConvertFromCastFunctionObject(value, index);
             }
             break;
@@ -160,7 +161,7 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
         case CastType::Float:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsNumber()) {
-                double floatArg = castValue->ToNumber(m_isolate)->NumberValue();
+                double floatArg = castValue->ToNumber(m_isolate)->NumberValue(context).ToChecked();
                 jfloat value = (jfloat) floatArg;
                 success = ConvertFromCastFunctionObject(value, index);
             }
@@ -169,7 +170,7 @@ bool JsArgConverter::ConvertArg(const Local<Value>& arg, int index) {
         case CastType::Double:
             castValue = NumericCasts::GetCastValue(jsObject);
             if (castValue->IsNumber()) {
-                double doubleArg = castValue->ToNumber(m_isolate)->NumberValue();
+                double doubleArg = castValue->ToNumber(m_isolate)->NumberValue(context).ToChecked();
                 jdouble value = (jdouble) doubleArg;
                 success = ConvertFromCastFunctionObject(value, index);
             }
@@ -230,20 +231,21 @@ bool JsArgConverter::ConvertJavaScriptNumber(const Local<Value>& jsValue, int in
     };
 
     const auto& typeSignature = m_tokens.at(index);
+    auto context = m_isolate->GetCurrentContext();
 
     const char typePrefix = typeSignature[0];
 
     switch (typePrefix) {
     case 'B': // byte
-        value.b = (jbyte) jsValue->Int32Value();
+        value.b = (jbyte) jsValue->Int32Value(context).ToChecked();
         break;
 
     case 'S': // short
-        value.s = (jshort) jsValue->Int32Value();
+        value.s = (jshort) jsValue->Int32Value(context).ToChecked();
         break;
 
     case 'I': // int
-        value.i = (jint) jsValue->Int32Value();
+        value.i = (jint) jsValue->Int32Value(context).ToChecked();
         break;
 
     case 'J': // long
@@ -252,16 +254,16 @@ bool JsArgConverter::ConvertJavaScriptNumber(const Local<Value>& jsValue, int in
             auto numObj = Local<NumberObject>::Cast(jsValue);
             value.j = (jlong) numObj->ValueOf();
         } else {
-            value.j = (jlong) jsValue->IntegerValue();
+            value.j = (jlong) jsValue->IntegerValue(context).ToChecked();
         }
         break;
 
     case 'F': // float
-        value.f = (jfloat) jsValue->NumberValue();
+        value.f = (jfloat) jsValue->NumberValue(context).ToChecked();
         break;
 
     case 'D': // double
-        value.d = (jdouble) jsValue->NumberValue();
+        value.d = (jdouble) jsValue->NumberValue(context).ToChecked();
         break;
 
     default:
@@ -280,16 +282,17 @@ bool JsArgConverter::ConvertJavaScriptBoolean(const Local<Value>& jsValue, int i
     bool success;
 
     const auto& typeSignature = m_tokens.at(index);
+    auto context = m_isolate->GetCurrentContext();
 
     if (typeSignature == "Z") {
         bool argValue;
         if (jsValue->IsBoolean()) {
-            argValue = jsValue->BooleanValue();
+            argValue = jsValue->BooleanValue(context).ToChecked();
         } else {
             auto boolObj = Local<BooleanObject>::Cast(jsValue);
             auto val = boolObj->Get(V8StringConstants::GetValueOf(m_isolate));
             if (!val.IsEmpty() && val->IsFunction()) {
-                argValue = val.As<Function>()->Call(boolObj, 0, nullptr)->BooleanValue();
+                argValue = val.As<Function>()->Call(boolObj, 0, nullptr)->BooleanValue(context).ToChecked();
             } else {
                 argValue = false;
             }
@@ -320,6 +323,7 @@ bool JsArgConverter::ConvertJavaScriptArray(const Local<Array>& jsArr, int index
     jsize arrLength = jsArr->Length();
 
     const auto& arraySignature = m_tokens.at(index);
+    auto context = m_isolate->GetCurrentContext();
 
     string elementType = arraySignature.substr(1);
 
@@ -332,21 +336,21 @@ bool JsArgConverter::ConvertJavaScriptArray(const Local<Array>& jsArr, int index
     case 'Z':
         arr = m_env.NewBooleanArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jboolean value = jsArr->Get(i)->BooleanValue();
+            jboolean value = jsArr->Get(i)->BooleanValue(context).ToChecked();
             m_env.SetBooleanArrayRegion((jbooleanArray) arr, i, 1, &value);
         }
         break;
     case 'B':
         arr = m_env.NewByteArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jbyte value = jsArr->Get(i)->Int32Value();
+            jbyte value = jsArr->Get(i)->Int32Value(context).ToChecked();
             m_env.SetByteArrayRegion((jbyteArray) arr, i, 1, &value);
         }
         break;
     case 'C':
         arr = m_env.NewCharArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            String::Utf8Value utf8(jsArr->Get(i)->ToString());
+            String::Utf8Value utf8(m_isolate, jsArr->Get(i)->ToString(m_isolate));
             JniLocalRef s(m_env.NewString((jchar*) *utf8, 1));
             const char* singleChar = m_env.GetStringUTFChars(s, nullptr);
             jchar value = *singleChar;
@@ -357,35 +361,35 @@ bool JsArgConverter::ConvertJavaScriptArray(const Local<Array>& jsArr, int index
     case 'S':
         arr = m_env.NewShortArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jshort value = jsArr->Get(i)->Int32Value();
+            jshort value = jsArr->Get(i)->Int32Value(context).ToChecked();
             m_env.SetShortArrayRegion((jshortArray) arr, i, 1, &value);
         }
         break;
     case 'I':
         arr = m_env.NewIntArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jint value = jsArr->Get(i)->Int32Value();
+            jint value = jsArr->Get(i)->Int32Value(context).ToChecked();
             m_env.SetIntArrayRegion((jintArray) arr, i, 1, &value);
         }
         break;
     case 'J':
         arr = m_env.NewLongArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jlong value = jsArr->Get(i)->NumberValue();
+            jlong value = jsArr->Get(i)->NumberValue(context).ToChecked();
             m_env.SetLongArrayRegion((jlongArray) arr, i, 1, &value);
         }
         break;
     case 'F':
         arr = m_env.NewFloatArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jfloat value = jsArr->Get(i)->NumberValue();
+            jfloat value = jsArr->Get(i)->NumberValue(context).ToChecked();
             m_env.SetFloatArrayRegion((jfloatArray) arr, i, 1, &value);
         }
         break;
     case 'D':
         arr = m_env.NewDoubleArray(arrLength);
         for (jsize i = 0; i < arrLength; i++) {
-            jdouble value = jsArr->Get(i)->NumberValue();
+            jdouble value = jsArr->Get(i)->NumberValue(context).ToChecked();
             m_env.SetDoubleArrayRegion((jdoubleArray) arr, i, 1, &value);
         }
         break;
diff --git a/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp b/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp
index 866e724e2..e37ee67dc 100644
--- a/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp
+++ b/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp
@@ -59,18 +59,19 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
     JEnv env;
 
     Type returnType = JType::getClassType(m_return_type);
+    auto context = m_isolate->GetCurrentContext();
 
     if (arg.IsEmpty()) {
         s << "Cannot convert empty JavaScript object";
         success = false;
     } else if (arg->IsInt32() && (returnType == Type::Int || returnType == Type::Null)) {
-        jint value = arg->Int32Value();
+        jint value = arg->Int32Value(context).ToChecked();
         auto javaObject = JType::NewInt(env, value);
         SetConvertedObject(env, index, javaObject);
 
         success = true;
     } else if (arg->IsNumber() || arg->IsNumberObject()) {
-        double d = arg->NumberValue();
+        double d = arg->NumberValue(context).ToChecked();
         int64_t i = (int64_t) d;
 
         //if returnType isNumber and this check is true, the number we'll try to convert is whole(integer)
@@ -109,13 +110,13 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             success = true;
         }
     } else if (arg->IsBoolean()) {
-        jboolean value = arg->BooleanValue();
+        jboolean value = arg->BooleanValue(context).ToChecked();
         auto javaObject = JType::NewBoolean(env, value);
         SetConvertedObject(env, index, javaObject);
         success = true;
     } else if (arg->IsBooleanObject()) {
         auto boolObj = Local<BooleanObject>::Cast(arg);
-        jboolean value = boolObj->BooleanValue() ? JNI_TRUE : JNI_FALSE;
+        jboolean value = boolObj->BooleanValue(context).ToChecked() ? JNI_TRUE : JNI_FALSE;
         auto javaObject = JType::NewBoolean(env, value);
         SetConvertedObject(env, index, javaObject);
 
@@ -126,7 +127,7 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
 
         success = true;
     } else if (arg->IsObject()) {
-        auto jsObj = arg->ToObject();
+        auto jsObj = arg->ToObject(m_isolate);
 
         auto castType = NumericCasts::GetCastType(m_isolate, jsObj);
 
@@ -148,7 +149,7 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             charValue = '\0';
             if (castValue->IsString()) {
-                string str = ArgConverter::ConvertToString(castValue->ToString());
+                string str = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 charValue = (jchar) str[0];
             }
             javaObject = JType::NewChar(env, charValue);
@@ -160,11 +161,11 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             byteValue = 0;
             if (castValue->IsString()) {
-                string value = ArgConverter::ConvertToString(castValue->ToString());
+                string value = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 int byteArg = atoi(value.c_str());
                 byteValue = (jbyte) byteArg;
             } else if (castValue->IsInt32()) {
-                int byteArg = castValue->ToInt32(m_isolate)->Int32Value();
+                int byteArg = castValue->ToInt32(m_isolate)->Int32Value(context).ToChecked();
                 byteValue = (jbyte) byteArg;
             }
             javaObject = JType::NewByte(env, byteValue);
@@ -176,11 +177,11 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             shortValue = 0;
             if (castValue->IsString()) {
-                string value = ArgConverter::ConvertToString(castValue->ToString());
+                string value = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 int shortArg = atoi(value.c_str());
                 shortValue = (jshort) shortArg;
             } else if (castValue->IsInt32()) {
-                jlong shortArg = castValue->ToInt32(m_isolate)->Int32Value();
+                jlong shortArg = castValue->ToInt32(m_isolate)->Int32Value(context).ToChecked();
                 shortValue = (jshort) shortArg;
             }
             javaObject = JType::NewShort(env, shortValue);
@@ -192,10 +193,10 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             longValue = 0;
             if (castValue->IsString()) {
-                auto strValue = ArgConverter::ConvertToString(castValue->ToString());
+                auto strValue = ArgConverter::ConvertToString(castValue->ToString(m_isolate));
                 longValue = atoll(strValue.c_str());
             } else if (castValue->IsInt32()) {
-                longValue = castValue->ToInt32(m_isolate)->Int32Value();
+                longValue = castValue->ToInt32(m_isolate)->Int32Value(context).ToChecked();
             }
             javaObject = JType::NewLong(env, longValue);
             SetConvertedObject(env, index, javaObject);
@@ -206,7 +207,7 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             floatValue = 0;
             if (castValue->IsNumber()) {
-                double floatArg = castValue->ToNumber(m_isolate)->NumberValue();
+                double floatArg = castValue->ToNumber(m_isolate)->NumberValue(context).ToChecked();
                 floatValue = (jfloat) floatArg;
             }
             javaObject = JType::NewFloat(env, floatValue);
@@ -218,7 +219,7 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             castValue = NumericCasts::GetCastValue(jsObj);
             doubleValue = 0;
             if (castValue->IsNumber()) {
-                double doubleArg = castValue->ToNumber(m_isolate)->NumberValue();
+                double doubleArg = castValue->ToNumber(m_isolate)->NumberValue(context).ToChecked();
                 doubleValue = (jdouble) doubleArg;
             }
             javaObject = JType::NewDouble(env, doubleValue);
@@ -263,7 +264,7 @@ bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) {
             if (success) {
                 SetConvertedObject(env, index, obj.Move(), obj.IsGlobal());
             } else {
-                String::Utf8Value jsObjStr(jsObj);
+                String::Utf8Value jsObjStr(m_isolate, jsObj);
                 s << "Cannot marshal JavaScript argument " << (*jsObjStr ? *jsObjStr : "<failed-to-string>") << " at index " << index << " to Java type.";
             }
             break;
diff --git a/test-app/runtime/src/main/cpp/JsV8InspectorClient.cpp b/test-app/runtime/src/main/cpp/JsV8InspectorClient.cpp
index ca5af221a..2be0386a8 100644
--- a/test-app/runtime/src/main/cpp/JsV8InspectorClient.cpp
+++ b/test-app/runtime/src/main/cpp/JsV8InspectorClient.cpp
@@ -205,12 +205,13 @@ void JsV8InspectorClient::sendToFrontEndCallback(const v8::FunctionCallbackInfo<
     }
 
     try {
+        auto isolate = args.GetIsolate();
         if ((args.Length() > 0) && args[0]->IsString()) {
-            std::string message = ArgConverter::ConvertToString(args[0]->ToString());
+            std::string message = ArgConverter::ConvertToString(args[0]->ToString(isolate));
 
             std::string level = "log";
             if (args.Length() > 1  && args[1]->IsString()) {
-                level = ArgConverter::ConvertToString(args[1]->ToString());
+                level = ArgConverter::ConvertToString(args[1]->ToString(isolate));
             }
 
             JEnv env;
@@ -239,7 +240,7 @@ void JsV8InspectorClient::consoleLogCallback(const string& message, const string
     auto isolate = Runtime::GetRuntime(0)->GetIsolate();
     auto stack = v8::StackTrace::CurrentStackTrace(isolate, 1, v8::StackTrace::StackTraceOptions::kDetailed);
 
-    auto frame = stack->GetFrame(0);
+    auto frame = stack->GetFrame(isolate, 0);
 
     // will be no-op in non-debuggable builds
     v8_inspector::V8LogAgentImpl::EntryAdded(message, logLevel, ArgConverter::ConvertToString(frame->GetScriptNameOrSourceURL()), frame->GetLineNumber());
diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp
index b29748cb7..3de140281 100644
--- a/test-app/runtime/src/main/cpp/MetadataNode.cpp
+++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp
@@ -57,7 +57,7 @@ Local<Object> MetadataNode::CreateExtendedJSWrapper(Isolate* isolate, ObjectMana
         auto extdCtorFunc = Local<Function>::New(isolate, *cacheData.extendedCtorFunction);
         auto context = isolate->GetCurrentContext();
         extInstance->SetPrototype(context, extdCtorFunc->Get(V8StringConstants::GetPrototype(isolate)));
-        extInstance->Set(ConvertToV8String("constructor"), extdCtorFunc);
+        extInstance->Set(ArgConverter::ConvertToV8String(isolate, "constructor"), extdCtorFunc);
 
         SetInstanceMetadata(isolate, extInstance, cacheData.node);
     }
@@ -308,8 +308,8 @@ void MetadataNode::FieldAccessorGetterCallback(Local<Name> property, const Prope
         auto fieldCallbackData = reinterpret_cast<FieldCallbackData*>(info.Data().As<External>()->Value());
 
         if ((!fieldCallbackData->isStatic && thiz->StrictEquals(info.Holder()))
-            // check whether there's a declaring type to get the class from it
-            || (fieldCallbackData->declaringType == "")) {
+                // check whether there's a declaring type to get the class from it
+                || (fieldCallbackData->declaringType == "")) {
             info.GetReturnValue().SetUndefined();
             return;
         }
@@ -462,13 +462,13 @@ vector<MetadataNode::MethodCallbackData*> MetadataNode::SetInstanceMethodsFromSt
             auto funcData = External::New(isolate, callbackData);
             auto funcTemplate = FunctionTemplate::New(isolate, MethodCallback, funcData);
 
-            auto funcName = ConvertToV8String(entry.name);
+            auto funcName = ArgConverter::ConvertToV8String(isolate, entry.name);
 
             if (s_profilerEnabled) {
                 auto func = funcTemplate->GetFunction();
                 Local<Function> wrapperFunc = Wrap(isolate, func, entry.name, origin, false /* isCtorFunc */);
                 Local<Function> ctorFunc = ctorFuncTemplate->GetFunction();
-                Local<Object> protoObject = ctorFunc->Get(ConvertToV8String("prototype")).As<Object>();
+                Local<Object> protoObject = ctorFunc->Get(ArgConverter::ConvertToV8String(isolate, "prototype")).As<Object>();
                 if (!protoObject.IsEmpty() && !protoObject->IsUndefined() && !protoObject->IsNull()) {
                     protoObject->Set(funcName, wrapperFunc);
                 }
@@ -516,7 +516,7 @@ void MetadataNode::SetInstanceFieldsFromStaticMetadata(Isolate* isolate, Local<F
     for (auto i = 0; i < instanceFieldCout; i++) {
         auto entry = s_metadataReader.ReadInstanceFieldEntry(&curPtr);
 
-        auto fieldName = ConvertToV8String(entry.name);
+        auto fieldName = ArgConverter::ConvertToV8String(isolate, entry.name);
         auto fieldInfo = new FieldCallbackData(entry);
         fieldInfo->declaringType = curType;
         auto fieldData = External::New(isolate, fieldInfo);
@@ -883,7 +883,7 @@ void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfo<v
             if (!info[0]->IsObject()) {
                 throw NativeScriptException(string("First argument must be implementation object"));
             }
-            implementationObject = info[0]->ToObject();
+            implementationObject = info[0]->ToObject(isolate);
         } else if (info.Length() == 2) {
             if (!info[0]->IsString()) {
                 throw NativeScriptException(string("First argument must be string"));
@@ -892,8 +892,8 @@ void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfo<v
                 throw NativeScriptException(string("Second argument must be implementation object"));
             }
 
-            v8ExtendName = info[0]->ToString();
-            implementationObject = info[1]->ToObject();
+            v8ExtendName = info[0]->ToString(isolate);
+            implementationObject = info[1]->ToObject(isolate);
         } else {
             throw NativeScriptException(string("Invalid number of arguments"));
         }
@@ -1219,6 +1219,7 @@ void MetadataNode::PackageGetterCallback(Local<Name> property, const PropertyCal
 }
 
 bool MetadataNode::ValidateExtendArguments(const FunctionCallbackInfo<Value>& info, bool extendLocationFound, string& extendLocation, v8::Local<v8::String>& extendName, Local<Object>& implementationObject, bool isTypeScriptExtend) {
+    auto isolate = info.GetIsolate();
 
     if (info.Length() == 1) {
         if (!extendLocationFound) {
@@ -1237,7 +1238,7 @@ bool MetadataNode::ValidateExtendArguments(const FunctionCallbackInfo<Value>& in
             throw NativeScriptException(exceptionMessage);
         }
 
-        implementationObject = info[0]->ToObject();
+        implementationObject = info[0]->ToObject(isolate);
     } else if (info.Length() == 2 || isTypeScriptExtend) {
         if (!info[0]->IsString()) {
             stringstream ss;
@@ -1256,7 +1257,7 @@ bool MetadataNode::ValidateExtendArguments(const FunctionCallbackInfo<Value>& in
         }
 
         DEBUG_WRITE("ExtendsCallMethodHandler: getting extend name");
-        extendName = info[0]->ToString();
+        extendName = info[0]->ToString(isolate);
         bool isValidExtendName = IsValidExtendName(extendName);
         if (!isValidExtendName) {
             stringstream ss;
@@ -1265,7 +1266,7 @@ bool MetadataNode::ValidateExtendArguments(const FunctionCallbackInfo<Value>& in
 
             throw NativeScriptException(exceptionMessage);
         }
-        implementationObject = info[1]->ToObject();
+        implementationObject = info[1]->ToObject(isolate);
     } else {
         stringstream ss;
         ss << "Invalid extend() call at location: " << extendLocation.c_str();
@@ -1317,6 +1318,7 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value
 
         auto hasDot = false;
         auto isTypeScriptExtend = false;
+        auto isolate = info.GetIsolate();
         if (info.Length() == 2) {
             if (info[0].IsEmpty() || !info[0]->IsString()) {
                 stringstream ss;
@@ -1335,7 +1337,8 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value
             string strName = ArgConverter::ConvertToString(info[0].As<String>());
             hasDot = strName.find('.') != string::npos;
         } else if (info.Length() == 3) {
-            if (info[2]->IsBoolean() && info[2]->BooleanValue()) {
+            auto context = isolate->GetCurrentContext();
+            if (info[2]->IsBoolean() && info[2]->BooleanValue(context).ToChecked()) {
                 isTypeScriptExtend = true;
             }
         }
@@ -1344,7 +1347,7 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value
             extendName = info[0].As<String>();
             implementationObject = info[1].As<Object>();
         } else {
-            auto isValidExtendLocation = GetExtendLocation(extendLocation, isTypeScriptExtend);
+            auto isValidExtendLocation = GetExtendLocation(isolate, extendLocation, isTypeScriptExtend);
             auto validArgs = ValidateExtendArguments(info, isValidExtendLocation, extendLocation, extendName, implementationObject, isTypeScriptExtend);
 
             if (!validArgs) {
@@ -1365,8 +1368,6 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value
             fullClassName = ArgConverter::ConvertToString(info[0].As<String>());
         }
 
-        auto isolate = info.GetIsolate();
-
         //resolve class (pre-generated or generated runtime from dex generator)
         uint8_t nodeType = s_metadataReader.GetNodeType(node->m_treeNode);
         bool isInterface = s_metadataReader.IsNodeTypeInterface(nodeType);
@@ -1454,15 +1455,15 @@ bool MetadataNode::IsValidExtendName(const Local<String>& name) {
     return true;
 }
 
-bool MetadataNode::GetExtendLocation(string& extendLocation, bool isTypeScriptExtend) {
+bool MetadataNode::GetExtendLocation(v8::Isolate* isolate, string& extendLocation, bool isTypeScriptExtend) {
     stringstream extendLocationStream;
     auto stackTrace = StackTrace::CurrentStackTrace(Isolate::GetCurrent(), 3, StackTrace::kOverview);
     if (!stackTrace.IsEmpty()) {
         Local<StackFrame> frame;
         if (isTypeScriptExtend) {
-            frame = stackTrace->GetFrame(2); // the _super.apply call to ts_helpers will always be the third call frame
+            frame = stackTrace->GetFrame(isolate, 2); // the _super.apply call to ts_helpers will always be the third call frame
         }  else {
-            frame = stackTrace->GetFrame(0);
+            frame = stackTrace->GetFrame(isolate, 0);
         }
 
         if (!frame.IsEmpty()) {
@@ -1614,12 +1615,12 @@ void MetadataNode::BuildMetadata(const string& filesPath) {
     timeval time2;
     gettimeofday(&time2, nullptr);
 
-    __android_log_print(ANDROID_LOG_DEBUG, "TNS.Native", "lenNodes=%d, lenNames=%d, lenValues=%d", lenNodes, lenNames, lenValues);
+    DEBUG_WRITE("lenNodes=%d, lenNames=%d, lenValues=%d", lenNodes, lenNames, lenValues);
 
     long millis1 = (time1.tv_sec * 1000) + (time1.tv_usec / 1000);
     long millis2 = (time2.tv_sec * 1000) + (time2.tv_usec / 1000);
 
-    __android_log_print(ANDROID_LOG_DEBUG, "TNS.Native", "time=%ld", (millis2 - millis1));
+    DEBUG_WRITE("time=%ld", (millis2 - millis1));
 
     BuildMetadata(lenNodes, reinterpret_cast<uint8_t*>(nodes), lenNames, reinterpret_cast<uint8_t*>(names), lenValues, reinterpret_cast<uint8_t*>(values));
 
@@ -1646,7 +1647,7 @@ void MetadataNode::CreateTopLevelNamespaces(Isolate* isolate, const Local<Object
             auto packageObj = node->CreateWrapper(isolate);
             string nameSpace = node->m_treeNode->name;
             // if the namespaces matches a javascript keyword, prefix it with $ to avoid TypeScript and JavaScript errors
-            if(IsJavascriptKeyword(nameSpace)) {
+            if (IsJavascriptKeyword(nameSpace)) {
                 nameSpace = "$" + nameSpace;
             }
             global->Set(ArgConverter::ConvertToV8String(isolate, nameSpace), packageObj);
@@ -1678,7 +1679,7 @@ bool MetadataNode::IsJavascriptKeyword(std::string word) {
                       "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements",
                       "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return",
                       "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "var", "void", "volatile", "while", "with", "yield"
-        };
+                    };
 
         keywords = set<string>(kw, kw + sizeof(kw)/sizeof(kw[0]));
     }
@@ -1732,7 +1733,7 @@ Local<Function> MetadataNode::Wrap(Isolate* isolate, const Local<Function>& func
         if (!result.IsEmpty()) {
             ret = result.As<Function>();
             ret->Set(ArgConverter::ConvertToV8String(isolate, "__func"), function);
-            ret->SetName(ConvertToV8String(actualName));
+            ret->SetName(ArgConverter::ConvertToV8String(isolate, actualName));
 
             auto prototypePropName = V8StringConstants::GetPrototype(isolate);
             ret->Set(prototypePropName, function->Get(prototypePropName));
@@ -1806,7 +1807,7 @@ void MetadataNode::SetMissingBaseMethods(Isolate* isolate, const vector<Metadata
 
                 auto funcData = External::New(isolate, callbackData);
                 auto funcTemplate = FunctionTemplate::New(isolate, MethodCallback, funcData);
-                auto funcName = ConvertToV8String(entry.name);
+                auto funcName = ArgConverter::ConvertToV8String(isolate, entry.name);
                 prototypeTemplate->Set(funcName, funcTemplate);
             }
 
@@ -1842,7 +1843,7 @@ void MetadataNode::RegisterSymbolHasInstanceCallback(Isolate* isolate, MetadataE
     auto hasInstanceFunc = hasInstanceTemplate->GetFunction();
     PropertyDescriptor descriptor(hasInstanceFunc, false);
     auto hasInstanceSymbol = Symbol::GetHasInstance(isolate);
-    interface->ToObject()->DefineProperty(isolate->GetCurrentContext(), hasInstanceSymbol, descriptor);
+    interface->ToObject(isolate)->DefineProperty(isolate->GetCurrentContext(), hasInstanceSymbol, descriptor);
 }
 
 void MetadataNode::SymbolHasInstanceCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
@@ -1862,7 +1863,7 @@ void MetadataNode::SymbolHasInstanceCallback(const v8::FunctionCallbackInfo<v8::
     auto isolate = info.GetIsolate();
     auto runtime = Runtime::GetRuntime(isolate);
     auto objectManager = runtime->GetObjectManager();
-    auto obj = objectManager->GetJavaObjectByJsObject(arg->ToObject());
+    auto obj = objectManager->GetJavaObjectByJsObject(arg->ToObject(isolate));
 
     if (obj.IsNull()) {
         // Couldn't find a corresponding java instance counterpart. This could happen
diff --git a/test-app/runtime/src/main/cpp/MetadataNode.h b/test-app/runtime/src/main/cpp/MetadataNode.h
index 77c36b8a6..c46237ddc 100644
--- a/test-app/runtime/src/main/cpp/MetadataNode.h
+++ b/test-app/runtime/src/main/cpp/MetadataNode.h
@@ -128,7 +128,7 @@ class MetadataNode {
         static void ArrayIndexedPropertySetterCallback(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info);
 
         static bool IsValidExtendName(const v8::Local<v8::String>& name);
-        static bool GetExtendLocation(std::string& extendLocation, bool isTypeScriptExtend);
+        static bool GetExtendLocation(v8::Isolate* isolate, std::string& extendLocation, bool isTypeScriptExtend);
         static ExtendedClassCacheData GetCachedExtendedClassData(v8::Isolate* isolate, const std::string& proxyClassName);
 
         static void RegisterSymbolHasInstanceCallback(v8::Isolate* isolate, MetadataEntry entry, v8::Local<v8::Value> interface);
diff --git a/test-app/runtime/src/main/cpp/MethodCache.cpp b/test-app/runtime/src/main/cpp/MethodCache.cpp
index 40506fb61..2eddbb107 100644
--- a/test-app/runtime/src/main/cpp/MethodCache.cpp
+++ b/test-app/runtime/src/main/cpp/MethodCache.cpp
@@ -118,7 +118,7 @@ string MethodCache::GetType(Isolate* isolate, const v8::Local<v8::Value>& value)
     string type;
 
     if (value->IsObject()) {
-        auto objVal = value->ToObject();
+        auto objVal = value->ToObject(isolate);
         Local<Value> nullNode; //out
         V8GetPrivateValue(isolate, objVal, V8StringConstants::GetNullNodeName(isolate), nullNode);
 
@@ -152,13 +152,14 @@ string MethodCache::GetType(Isolate* isolate, const v8::Local<v8::Value>& value)
     } else if (value->IsString() || value->IsStringObject()) {
         type = "string";
     } else if (value->IsNumber() || value->IsNumberObject()) {
-        double d = value->NumberValue();
+        auto context = isolate->GetCurrentContext();
+        double d = value->NumberValue(context).ToChecked();
         int64_t i = (int64_t) d;
         bool isInteger = d == i;
 
         type = isInteger ? "intnumber" : "doublenumber";
     } else if (value->IsObject()) {
-        auto object = value->ToObject();
+        auto object = value->ToObject(isolate);
         auto castType = NumericCasts::GetCastType(isolate, object);
         MetadataNode* node;
 
diff --git a/test-app/runtime/src/main/cpp/ModuleInternal.cpp b/test-app/runtime/src/main/cpp/ModuleInternal.cpp
index 4e30fdaf3..02e989adb 100644
--- a/test-app/runtime/src/main/cpp/ModuleInternal.cpp
+++ b/test-app/runtime/src/main/cpp/ModuleInternal.cpp
@@ -286,7 +286,8 @@ Local<Object> ModuleInternal::LoadModule(Isolate* isolate, const string& moduleP
     if (Util::EndsWith(modulePath, ".js")) {
         auto script = LoadScript(isolate, modulePath, fullRequiredModulePath);
 
-        moduleFunc = script->Run().As<Function>();
+        auto context = isolate->GetCurrentContext();
+        moduleFunc = script->Run(context).ToLocalChecked().As<Function>();
         if (tc.HasCaught()) {
             throw NativeScriptException(tc, "Error running script " + modulePath);
         }
@@ -378,15 +379,12 @@ Local<Script> ModuleInternal::LoadScript(Isolate* isolate, const string& path, c
         script = maybeScript.ToLocalChecked();
     } else {
         tns::instrumentation::Frame frame("Compile, no cache");
-        if (Constants::V8_CACHE_COMPILED_CODE) {
-            option = ScriptCompiler::kProduceCodeCache;
-        }
         auto maybeScript = ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, option);
         if (maybeScript.IsEmpty() || tc.HasCaught()) {
             throw NativeScriptException(tc, "Cannot compile " + path);
         }
         script = maybeScript.ToLocalChecked();
-        SaveScriptCache(source, path);
+        SaveScriptCache(script, path);
     }
 
     DEBUG_WRITE("Compiled script (module %s)", path.c_str());
@@ -458,16 +456,19 @@ ScriptCompiler::CachedData* ModuleInternal::TryLoadScriptCache(const std::string
     return new ScriptCompiler::CachedData(reinterpret_cast<uint8_t*>(data), length, ScriptCompiler::CachedData::BufferOwned);
 }
 
-void ModuleInternal::SaveScriptCache(const ScriptCompiler::Source& source, const std::string& path) {
+void ModuleInternal::SaveScriptCache(const Local<Script> script, const std::string& path) {
     if (!Constants::V8_CACHE_COMPILED_CODE) {
         return;
     }
 
     tns::instrumentation::Frame frame("SaveScriptCache");
 
-    int length = source.GetCachedData()->length;
+    Local<UnboundScript> unboundScript = script->GetUnboundScript();
+    ScriptCompiler::CachedData* cachedData = ScriptCompiler::CreateCodeCache(unboundScript);
+
+    int length = cachedData->length;
     auto cachePath = path + ".cache";
-    File::WriteBinary(cachePath, source.GetCachedData()->data, length);
+    File::WriteBinary(cachePath, cachedData->data, length);
 }
 
 ModuleInternal::ModulePathKind ModuleInternal::GetModulePathKind(const std::string& path) {
diff --git a/test-app/runtime/src/main/cpp/ModuleInternal.h b/test-app/runtime/src/main/cpp/ModuleInternal.h
index c0731d157..7d7b8d06c 100644
--- a/test-app/runtime/src/main/cpp/ModuleInternal.h
+++ b/test-app/runtime/src/main/cpp/ModuleInternal.h
@@ -61,7 +61,7 @@ class ModuleInternal {
 
         v8::ScriptCompiler::CachedData* TryLoadScriptCache(const std::string& path);
 
-        void SaveScriptCache(const v8::ScriptCompiler::Source& source, const std::string& path);
+        void SaveScriptCache(const v8::Local<v8::Script> script, const std::string& path);
 
         ModulePathKind GetModulePathKind(const std::string& path);
 
diff --git a/test-app/runtime/src/main/cpp/NativeScriptException.cpp b/test-app/runtime/src/main/cpp/NativeScriptException.cpp
index 468fcbdf6..e821629f3 100644
--- a/test-app/runtime/src/main/cpp/NativeScriptException.cpp
+++ b/test-app/runtime/src/main/cpp/NativeScriptException.cpp
@@ -103,7 +103,7 @@ void NativeScriptException::ReThrowToJava() {
     env.Throw(ex);
 }
 
-void NativeScriptException::Init(ObjectManager* objectManager) {
+void NativeScriptException::Init() {
     JEnv env;
 
     RUNTIME_CLASS = env.FindClass("com/tns/Runtime");
@@ -133,14 +133,15 @@ void NativeScriptException::OnUncaughtError(Local<Message> message, Local<Value>
     e.ReThrowToJava();
 }
 
-void NativeScriptException::CallJsFuncWithErr(Local<Value> errObj) {
+void NativeScriptException::CallJsFuncWithErr(Local<Value> errObj, jboolean isDiscarded) {
     auto isolate = Isolate::GetCurrent();
     HandleScope scope(isolate);
 
     auto context = isolate->GetCurrentContext();
     auto globalHandle = context->Global();
 
-    auto handler = globalHandle->Get(V8StringConstants::GetUncaughtError(isolate));
+    auto handler = isDiscarded ?
+       globalHandle->Get(V8StringConstants::GetDiscardedError(isolate)) : globalHandle->Get(V8StringConstants::GetUncaughtError(isolate));
     auto isEmpty = handler.IsEmpty();
     auto isFunction = handler->IsFunction();
 
@@ -303,7 +304,7 @@ string NativeScriptException::GetErrorMessage(const Local<Message>& message, Loc
     } else {
         ss << "File: \"<unknown>";
     }
-    ss << ", line: " << message->GetLineNumber() << ", column: " << message->GetStartColumn() << endl << endl;
+    ss << ", line: " << message->GetLineNumber(context).ToChecked() << ", column: " << message->GetStartColumn() << endl << endl;
     ss << "StackTrace: " << endl << stackTraceMessage << endl;
 
     return ss.str();
@@ -318,7 +319,7 @@ string NativeScriptException::GetErrorStackTrace(const Local<StackTrace>& stackT
     int frameCount = stackTrace->GetFrameCount();
 
     for (int i = 0; i < frameCount; i++) {
-        auto frame = stackTrace->GetFrame(i);
+        auto frame = stackTrace->GetFrame(isolate, i);
         auto funcName = ArgConverter::ConvertToString(frame->GetFunctionName());
         auto srcName = ArgConverter::ConvertToString(frame->GetScriptName());
         auto lineNumber = frame->GetLineNumber();
diff --git a/test-app/runtime/src/main/cpp/NativeScriptException.h b/test-app/runtime/src/main/cpp/NativeScriptException.h
index e4dbbf533..74d23e576 100644
--- a/test-app/runtime/src/main/cpp/NativeScriptException.h
+++ b/test-app/runtime/src/main/cpp/NativeScriptException.h
@@ -28,7 +28,7 @@ class NativeScriptException {
         void ReThrowToV8();
         void ReThrowToJava();
 
-        static void Init(ObjectManager* objectManager);
+        static void Init();
 
         /*
          * This handler is attached to v8 to handle uncaught javascript exceptions.
@@ -36,9 +36,9 @@ class NativeScriptException {
         static void OnUncaughtError(v8::Local<v8::Message> message, v8::Local<v8::Value> error);
 
         /*
-         * Calls the global "__onUncaughtError" if such is provided
+         * Calls the global "__onUncaughtError" or "__onDiscardedError" if such is provided
          */
-        static void CallJsFuncWithErr(v8::Local<v8::Value> errObj);
+        static void CallJsFuncWithErr(v8::Local<v8::Value> errObj, jboolean isDiscarded);
 
     private:
         /*
diff --git a/test-app/runtime/src/main/cpp/NetworkDomainCallbackHandlers.cpp b/test-app/runtime/src/main/cpp/NetworkDomainCallbackHandlers.cpp
index 341807c92..48f76439f 100644
--- a/test-app/runtime/src/main/cpp/NetworkDomainCallbackHandlers.cpp
+++ b/test-app/runtime/src/main/cpp/NetworkDomainCallbackHandlers.cpp
@@ -27,7 +27,7 @@ void NetworkDomainCallbackHandlers::ResponseReceivedCallback(const v8::FunctionC
 
         auto context = isolate->GetCurrentContext();
 
-        v8::Local<v8::Object> argsObj = args[0]->ToObject();
+        v8::Local<v8::Object> argsObj = args[0]->ToObject(isolate);
 
         if ((!argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "requestId")).FromMaybe(false) ||
                 !argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).FromMaybe(false) ||
@@ -36,12 +36,12 @@ void NetworkDomainCallbackHandlers::ResponseReceivedCallback(const v8::FunctionC
             throw NativeScriptException(wrongParametersError);
         }
 
-        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString();
-        auto type = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "type")).ToLocalChecked()->ToString();
+        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString(isolate);
+        auto type = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "type")).ToLocalChecked()->ToString(isolate);
         auto response = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "response")).ToLocalChecked();
-        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue();
+        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue(context).ToChecked();
 
-        auto responseAsObj = response->ToObject();
+        auto responseAsObj = response->ToObject(isolate);
         auto connectionReusedProp = ArgConverter::ConvertToV8String(isolate, "connectionReused");
         if (!responseAsObj->Has(context, connectionReusedProp).FromMaybe(false)) {
             responseAsObj->Set(connectionReusedProp, v8::Boolean::New(isolate, true));
@@ -129,7 +129,7 @@ void NetworkDomainCallbackHandlers::RequestWillBeSentCallback(const v8::Function
 
         auto context = isolate->GetCurrentContext();
 
-        v8::Local<v8::Object> argsObj = args[0]->ToObject();
+        v8::Local<v8::Object> argsObj = args[0]->ToObject(isolate);
 
         if ((!(argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "requestId")).FromMaybe(false)) ||
                 !(argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "url")).FromMaybe(false)) ||
@@ -139,17 +139,17 @@ void NetworkDomainCallbackHandlers::RequestWillBeSentCallback(const v8::Function
             throw NativeScriptException(wrongParametersError);
         }
 
-        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString();
-        auto url = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "url")).ToLocalChecked()->ToString();
+        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString(isolate);
+        auto url = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "url")).ToLocalChecked()->ToString(isolate);
         auto request = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "request")).ToLocalChecked();
-        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue();
-        auto typeArg = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "type")).ToLocalChecked()->ToString();
+        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue(context).ToChecked();
+        auto typeArg = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "type")).ToLocalChecked()->ToString(isolate);
         long long int wallTime = 0;
         if (argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "wallTime")).FromMaybe(true)) {
-            wallTime = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "wallTime")).ToLocalChecked()->ToNumber(isolate)->IntegerValue();
+            wallTime = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "wallTime")).ToLocalChecked()->ToNumber(isolate)->IntegerValue(context).ToChecked();
         }
 
-        auto requestAsObj = request->ToObject();
+        auto requestAsObj = request->ToObject(isolate);
         auto initialPriorityProp = ArgConverter::ConvertToV8String(isolate, "initialPriority");
         auto referrerPolicyProp = ArgConverter::ConvertToV8String(isolate, "referrerPolicy");
         if (!argsObj->Has(context, initialPriorityProp).FromMaybe(false)) {
@@ -230,7 +230,7 @@ void NetworkDomainCallbackHandlers::DataForRequestIdCallback(const v8::FunctionC
 
         auto context = isolate->GetCurrentContext();
 
-        v8::Local<v8::Object> argsObj = args[0]->ToObject();
+        v8::Local<v8::Object> argsObj = args[0]->ToObject(isolate);
 
         if (!argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "requestId")).FromMaybe(false) ||
                 !argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "data")).FromMaybe(false) ||
@@ -238,13 +238,13 @@ void NetworkDomainCallbackHandlers::DataForRequestIdCallback(const v8::FunctionC
             throw NativeScriptException(wrongParametersError);
         }
 
-        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString();
-        auto data = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "data")).ToLocalChecked()->ToString();
-        auto hasTextContent = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "hasTextContent")).ToLocalChecked()->ToBoolean();
+        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString(isolate);
+        auto data = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "data")).ToLocalChecked()->ToString(context).ToLocalChecked();
+        auto hasTextContent = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "hasTextContent")).ToLocalChecked()->ToBoolean(context).ToLocalChecked();
 
         auto requestIdString = ArgConverter::ConvertToString(requestId);
         auto dataString = ArgConverter::ConvertToUtf16String(data);
-        auto hasTextContentBool = hasTextContent->BooleanValue();
+        auto hasTextContentBool = hasTextContent->BooleanValue(context).ToChecked();
 
         auto responses = networkAgentInstance->m_responses;
         auto it = responses.find(requestIdString);
@@ -290,19 +290,19 @@ void NetworkDomainCallbackHandlers::LoadingFinishedCallback(const v8::FunctionCa
 
         auto context = isolate->GetCurrentContext();
 
-        v8::Local<v8::Object> argsObj = args[0]->ToObject();
+        v8::Local<v8::Object> argsObj = args[0]->ToObject(isolate);
 
         if (!argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "requestId")).FromMaybe(false) ||
                 !argsObj->Has(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).FromMaybe(false)) {
             throw NativeScriptException(wrongParametersError);
         }
 
-        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString();
-        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue();
+        auto requestId = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "requestId")).ToLocalChecked()->ToString(isolate);
+        auto timeStamp = argsObj->Get(context, ArgConverter::ConvertToV8String(isolate, "timestamp")).ToLocalChecked()->ToNumber(isolate)->IntegerValue(context).ToChecked();
         long long int encodedDataLength = 0;
         auto encodedDataLengthProp = ArgConverter::ConvertToV8String(isolate, "encodedDataLength");
         if (argsObj->Has(context, encodedDataLengthProp).FromMaybe(true)) {
-            encodedDataLength = argsObj->Get(context, encodedDataLengthProp).ToLocalChecked()->ToNumber(isolate)->IntegerValue();
+            encodedDataLength = argsObj->Get(context, encodedDataLengthProp).ToLocalChecked()->ToNumber(isolate)->IntegerValue(context).ToChecked();
         }
 
         networkAgentInstance->m_frontend.loadingFinished(ArgConverter::ConvertToString(requestId).c_str(), timeStamp, encodedDataLength);
diff --git a/test-app/runtime/src/main/cpp/NumericCasts.cpp b/test-app/runtime/src/main/cpp/NumericCasts.cpp
index 4e6a66cc6..c0ae4bc2d 100644
--- a/test-app/runtime/src/main/cpp/NumericCasts.cpp
+++ b/test-app/runtime/src/main/cpp/NumericCasts.cpp
@@ -28,7 +28,8 @@ CastType NumericCasts::GetCastType(Isolate* isolate, const Local<Object>& object
     Local<Value> hidden;
     V8GetPrivateValue(isolate, object, key, hidden);
     if (!hidden.IsEmpty()) {
-        ret = static_cast<CastType>(hidden->Int32Value());
+        auto context = isolate->GetCurrentContext();
+        ret = static_cast<CastType>(hidden->Int32Value(context).ToChecked());
     }
 
     return ret;
@@ -175,7 +176,7 @@ void NumericCasts::MarkAsLongCallback(const v8::FunctionCallbackInfo<Value>& arg
         if (args[0]->IsInt32()) {
             value = args[0]->ToInt32(isolate);
         } else {
-            value = args[0]->ToString();
+            value = args[0]->ToString(isolate);
         }
 
         auto cast = Object::New(isolate);
@@ -209,7 +210,7 @@ void NumericCasts::MarkAsByteCallback(const v8::FunctionCallbackInfo<Value>& arg
         if (args[0]->IsInt32()) {
             value = args[0]->ToInt32(isolate);
         } else {
-            value = args[0]->ToString();
+            value = args[0]->ToString(isolate);
         }
 
         auto cast = Object::New(isolate);
@@ -244,7 +245,7 @@ void NumericCasts::MarkAsShortCallback(const v8::FunctionCallbackInfo<Value>& ar
         if (args[0]->IsInt32()) {
             value = args[0]->ToInt32(isolate);
         } else {
-            value = args[0]->ToString();
+            value = args[0]->ToString(isolate);
         }
 
         auto cast = Object::New(isolate);
@@ -274,7 +275,7 @@ void NumericCasts::MarkAsCharCallback(const v8::FunctionCallbackInfo<Value>& arg
             throw NativeScriptException(string("char(x) should be called with single parameter containing a char representation"));
         }
 
-        auto value = args[0]->ToString();
+        auto value = args[0]->ToString(isolate);
         if (value->Length() != 1) {
             throw NativeScriptException(string("char(x) should be called with single parameter containing a single char"));
         }
diff --git a/test-app/runtime/src/main/cpp/ObjectManager.cpp b/test-app/runtime/src/main/cpp/ObjectManager.cpp
index 0c91445a1..1feb802d3 100644
--- a/test-app/runtime/src/main/cpp/ObjectManager.cpp
+++ b/test-app/runtime/src/main/cpp/ObjectManager.cpp
@@ -18,28 +18,40 @@ using namespace std;
 using namespace tns;
 
 ObjectManager::ObjectManager(jobject javaRuntimeObject) :
-    m_javaRuntimeObject(javaRuntimeObject),
-    m_env(JEnv()),
-    m_numberOfGC(0),
-    m_currentObjectId(0),
-    m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this) {
+        m_javaRuntimeObject(javaRuntimeObject),
+        m_env(JEnv()),
+        m_numberOfGC(0),
+        m_currentObjectId(0),
+        m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this) {
 
     auto runtimeClass = m_env.FindClass("com/tns/Runtime");
     assert(runtimeClass != nullptr);
 
-    GET_JAVAOBJECT_BY_ID_METHOD_ID = m_env.GetMethodID(runtimeClass, "getJavaObjectByID", "(I)Ljava/lang/Object;");
+    GET_JAVAOBJECT_BY_ID_METHOD_ID = m_env.GetMethodID(runtimeClass, "getJavaObjectByID",
+                                                       "(I)Ljava/lang/Object;");
     assert(GET_JAVAOBJECT_BY_ID_METHOD_ID != nullptr);
 
-    GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID = m_env.GetMethodID(runtimeClass, "getOrCreateJavaObjectID", "(Ljava/lang/Object;)I");
+    GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID = m_env.GetMethodID(runtimeClass,
+                                                               "getOrCreateJavaObjectID",
+                                                               "(Ljava/lang/Object;)I");
     assert(GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID != nullptr);
 
-    MAKE_INSTANCE_WEAK_BATCH_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeak", "(Ljava/nio/ByteBuffer;IZ)V");
+    MAKE_INSTANCE_WEAK_BATCH_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeak",
+                                                           "(Ljava/nio/ByteBuffer;IZ)V");
     assert(MAKE_INSTANCE_WEAK_BATCH_METHOD_ID != nullptr);
 
-    MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeakAndCheckIfAlive", "(I)Z");
+    MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass,
+                                                                        "makeInstanceWeakAndCheckIfAlive",
+                                                                        "(I)Z");
     assert(MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID != nullptr);
 
-    CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "checkWeakObjectAreAlive", "(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;I)V");
+    RELEASE_NATIVE_INSTANCE_METHOD_ID = m_env.GetMethodID(runtimeClass, "releaseNativeCounterpart",
+                                                          "(I)V");
+    assert(RELEASE_NATIVE_INSTANCE_METHOD_ID != nullptr);
+
+    CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass,
+                                                               "checkWeakObjectAreAlive",
+                                                               "(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;I)V");
     assert(CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID != nullptr);
 
     JAVA_LANG_CLASS = m_env.FindClass("java/lang/Class");
@@ -54,18 +66,20 @@ ObjectManager::ObjectManager(jobject javaRuntimeObject) :
     auto useGlobalRefs = m_env.CallStaticBooleanMethod(runtimeClass, useGlobalRefsMethodID);
     m_useGlobalRefs = useGlobalRefs == JNI_TRUE;
 
-    auto getMarkingModeOrdinalMethodID = m_env.GetMethodID(runtimeClass, "getMarkingModeOrdinal", "()I");
+    auto getMarkingModeOrdinalMethodID = m_env.GetMethodID(runtimeClass, "getMarkingModeOrdinal",
+                                                           "()I");
     jint markingMode = m_env.CallIntMethod(m_javaRuntimeObject, getMarkingModeOrdinalMethodID);
     m_markingMode = static_cast<JavaScriptMarkingMode>(markingMode);
 }
 
-void ObjectManager::SetInstanceIsolate(Isolate* isolate) {
+void ObjectManager::SetInstanceIsolate(Isolate *isolate) {
     m_isolate = isolate;
 }
 
-void ObjectManager::Init(Isolate* isolate) {
+void ObjectManager::Init(Isolate *isolate) {
     auto jsWrapperFuncTemplate = FunctionTemplate::New(isolate, JSWrapperConstructorCallback);
-    jsWrapperFuncTemplate->InstanceTemplate()->SetInternalFieldCount(static_cast<int>(MetadataNodeKeys::END));
+    jsWrapperFuncTemplate->InstanceTemplate()->SetInternalFieldCount(
+            static_cast<int>(MetadataNodeKeys::END));
     auto jsWrapperFunc = jsWrapperFuncTemplate->GetFunction();
     m_poJsWrapperFunc = new Persistent<Function>(isolate, jsWrapperFunc);
 
@@ -76,15 +90,16 @@ void ObjectManager::Init(Isolate* isolate) {
 }
 
 
-JniLocalRef ObjectManager::GetJavaObjectByJsObject(const Local<Object>& object) {
-    JSInstanceInfo* jsInstanceInfo = GetJSInstanceInfo(object);
+JniLocalRef ObjectManager::GetJavaObjectByJsObject(const Local<Object> &object) {
+    JSInstanceInfo *jsInstanceInfo = GetJSInstanceInfo(object);
 
     if (jsInstanceInfo != nullptr) {
         if (m_useGlobalRefs) {
             JniLocalRef javaObject(GetJavaObjectByID(jsInstanceInfo->JavaObjectID), true);
             return javaObject;
         } else {
-            JniLocalRef javaObject(m_env.NewLocalRef(GetJavaObjectByID(jsInstanceInfo->JavaObjectID)));
+            JniLocalRef javaObject(
+                    m_env.NewLocalRef(GetJavaObjectByID(jsInstanceInfo->JavaObjectID)));
             return javaObject;
         }
     }
@@ -92,15 +107,16 @@ JniLocalRef ObjectManager::GetJavaObjectByJsObject(const Local<Object>& object)
     return JniLocalRef();
 }
 
-ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfo(const Local<Object>& object) {
-    JSInstanceInfo* jsInstanceInfo = nullptr;
+ObjectManager::JSInstanceInfo *ObjectManager::GetJSInstanceInfo(const Local<Object> &object) {
+    JSInstanceInfo *jsInstanceInfo = nullptr;
     if (IsJsRuntimeObject(object)) {
         return GetJSInstanceInfoFromRuntimeObject(object);
     }
     return nullptr;
 }
 
-ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfoFromRuntimeObject(const Local<Object>& object) {
+ObjectManager::JSInstanceInfo *
+ObjectManager::GetJSInstanceInfoFromRuntimeObject(const Local<Object> &object) {
     HandleScope handleScope(m_isolate);
 
     const int jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
@@ -110,7 +126,8 @@ ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfoFromRuntimeObject
         auto prototypeObject = object->GetPrototype().As<Object>();
 
         if (!prototypeObject.IsEmpty() && prototypeObject->IsObject()) {
-            DEBUG_WRITE("GetJSInstanceInfo: need to check prototype :%d", prototypeObject->GetIdentityHash());
+            DEBUG_WRITE("GetJSInstanceInfo: need to check prototype :%d",
+                        prototypeObject->GetIdentityHash());
             if (IsJsRuntimeObject(prototypeObject)) {
                 jsInfo = prototypeObject->GetInternalField(jsInfoIdx);
             }
@@ -119,13 +136,13 @@ ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfoFromRuntimeObject
 
     if (!jsInfo.IsEmpty() && jsInfo->IsExternal()) {
         auto external = jsInfo.As<External>();
-        return static_cast<JSInstanceInfo*>(external->Value());
+        return static_cast<JSInstanceInfo *>(external->Value());
     }
 
     return nullptr;
 }
 
-bool ObjectManager::IsJsRuntimeObject(const v8::Local<v8::Object>& object) {
+bool ObjectManager::IsJsRuntimeObject(const v8::Local<v8::Object> &object) {
     int internalFieldCount = object->InternalFieldCount();
     const int count = static_cast<int>(MetadataNodeKeys::END);
     return internalFieldCount == count;
@@ -138,7 +155,8 @@ jweak ObjectManager::GetJavaObjectByID(uint32_t javaObjectID) {
 }
 
 jobject ObjectManager::GetJavaObjectByIDImpl(uint32_t javaObjectID) {
-    jobject object = m_env.CallObjectMethod(m_javaRuntimeObject, GET_JAVAOBJECT_BY_ID_METHOD_ID, javaObjectID);
+    jobject object = m_env.CallObjectMethod(m_javaRuntimeObject, GET_JAVAOBJECT_BY_ID_METHOD_ID,
+                                            javaObjectID);
     return object;
 }
 
@@ -146,22 +164,23 @@ void ObjectManager::UpdateCache(int objectID, jobject obj) {
     m_cache.update(objectID, obj);
 }
 
-jclass ObjectManager::GetJavaClass(const Local<Object>& instance) {
+jclass ObjectManager::GetJavaClass(const Local<Object> &instance) {
     DEBUG_WRITE("GetClass called");
 
-    JSInstanceInfo* jsInfo = GetJSInstanceInfo(instance);
+    JSInstanceInfo *jsInfo = GetJSInstanceInfo(instance);
     jclass clazz = jsInfo->ObjectClazz;
 
     return clazz;
 }
 
-void ObjectManager::SetJavaClass(const Local<Object>& instance, jclass clazz) {
-    JSInstanceInfo* jsInfo = GetJSInstanceInfo(instance);
+void ObjectManager::SetJavaClass(const Local<Object> &instance, jclass clazz) {
+    JSInstanceInfo *jsInfo = GetJSInstanceInfo(instance);
     jsInfo->ObjectClazz = clazz;
 }
 
 int ObjectManager::GetOrCreateObjectId(jobject object) {
-    jint javaObjectID = m_env.CallIntMethod(m_javaRuntimeObject, GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID, object);
+    jint javaObjectID = m_env.CallIntMethod(m_javaRuntimeObject,
+                                            GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID, object);
 
     return javaObjectID;
 }
@@ -175,24 +194,26 @@ Local<Object> ObjectManager::GetJsObjectByJavaObject(int javaObjectID) {
         return handleScope.Escape(Local<Object>());
     }
 
-    Persistent<Object>* jsObject = it->second;
+    Persistent<Object> *jsObject = it->second;
 
     auto localObject = Local<Object>::New(isolate, *jsObject);
     return handleScope.Escape(localObject);
 }
 
 
-Local<Object> ObjectManager::CreateJSWrapper(jint javaObjectID, const string& typeName) {
+Local<Object> ObjectManager::CreateJSWrapper(jint javaObjectID, const string &typeName) {
     return CreateJSWrapperHelper(javaObjectID, typeName, nullptr);
 }
 
-Local<Object> ObjectManager::CreateJSWrapper(jint javaObjectID, const string& typeName, jobject instance) {
+Local<Object>
+ObjectManager::CreateJSWrapper(jint javaObjectID, const string &typeName, jobject instance) {
     JniLocalRef clazz(m_env.GetObjectClass(instance));
 
     return CreateJSWrapperHelper(javaObjectID, typeName, clazz);
 }
 
-Local<Object> ObjectManager::CreateJSWrapperHelper(jint javaObjectID, const string& typeName, jclass clazz) {
+Local<Object>
+ObjectManager::CreateJSWrapperHelper(jint javaObjectID, const string &typeName, jclass clazz) {
     auto isolate = m_isolate;
 
     auto className = (clazz != nullptr) ? GetClassName(clazz) : typeName;
@@ -212,7 +233,7 @@ Local<Object> ObjectManager::CreateJSWrapperHelper(jint javaObjectID, const stri
 /* *
  * Link the JavaScript object and it's java counterpart with an ID
  */
-void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jclass clazz) {
+void ObjectManager::Link(const Local<Object> &object, uint32_t javaObjectID, jclass clazz) {
     if (!IsJsRuntimeObject(object)) {
         string errMsg("Trying to link invalid 'this' to a Java object");
         throw NativeScriptException(errMsg);
@@ -220,7 +241,8 @@ void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jcl
 
     auto isolate = m_isolate;
 
-    DEBUG_WRITE("Linking js object: %d and java instance id: %d", object->GetIdentityHash(), javaObjectID);
+    DEBUG_WRITE("Linking js object: %d and java instance id: %d", object->GetIdentityHash(),
+                javaObjectID);
 
     auto jsInstanceInfo = new JSInstanceInfo(false/*isJavaObjWeak*/, javaObjectID, clazz);
 
@@ -244,7 +266,7 @@ void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jcl
     m_idToObject.insert(make_pair(javaObjectID, objectHandle));
 }
 
-bool ObjectManager::CloneLink(const Local<Object>& src, const Local<Object>& dest) {
+bool ObjectManager::CloneLink(const Local<Object> &src, const Local<Object> &dest) {
     auto jsInfo = GetJSInstanceInfo(src);
 
     auto success = jsInfo != nullptr;
@@ -274,29 +296,30 @@ string ObjectManager::GetClassName(jclass clazz) {
     return className;
 }
 
-void ObjectManager::JSObjectWeakCallbackStatic(const WeakCallbackInfo<ObjectWeakCallbackState>& data) {
-    ObjectWeakCallbackState* callbackState = data.GetParameter();
+void
+ObjectManager::JSObjectWeakCallbackStatic(const WeakCallbackInfo<ObjectWeakCallbackState> &data) {
+    ObjectWeakCallbackState *callbackState = data.GetParameter();
 
-    ObjectManager* thisPtr = callbackState->thisPtr;
+    ObjectManager *thisPtr = callbackState->thisPtr;
 
     auto isolate = data.GetIsolate();
 
     thisPtr->JSObjectWeakCallback(isolate, callbackState);
 }
 
-void ObjectManager::JSObjectFinalizerStatic(const WeakCallbackInfo<ObjectWeakCallbackState>& data) {
-    ObjectWeakCallbackState* callbackState = data.GetParameter();
+void ObjectManager::JSObjectFinalizerStatic(const WeakCallbackInfo<ObjectWeakCallbackState> &data) {
+    ObjectWeakCallbackState *callbackState = data.GetParameter();
 
-    ObjectManager* thisPtr = callbackState->thisPtr;
+    ObjectManager *thisPtr = callbackState->thisPtr;
 
     auto isolate = data.GetIsolate();
 
     thisPtr->JSObjectFinalizer(isolate, callbackState);
 }
 
-void ObjectManager::JSObjectFinalizer(Isolate* isolate, ObjectWeakCallbackState* callbackState) {
+void ObjectManager::JSObjectFinalizer(Isolate *isolate, ObjectWeakCallbackState *callbackState) {
     HandleScope handleScope(m_isolate);
-    Persistent<Object>* po = callbackState->target;
+    Persistent<Object> *po = callbackState->target;
     auto jsInstanceInfo = GetJSInstanceInfoFromRuntimeObject(po->Get(m_isolate));
 
     if (jsInstanceInfo == nullptr) {
@@ -305,7 +328,9 @@ void ObjectManager::JSObjectFinalizer(Isolate* isolate, ObjectWeakCallbackState*
     }
 
     auto javaObjectID = jsInstanceInfo->JavaObjectID;
-    jboolean isJavaInstanceAlive = m_env.CallBooleanMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID, javaObjectID);
+    jboolean isJavaInstanceAlive = m_env.CallBooleanMethod(m_javaRuntimeObject,
+                                                           MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID,
+                                                           javaObjectID);
     if (isJavaInstanceAlive) {
         // If the Java instance is alive, keep the JavaScript instance alive.
         po->SetWeak(callbackState, JSObjectFinalizerStatic, WeakCallbackType::kFinalizer);
@@ -326,10 +351,10 @@ void ObjectManager::JSObjectFinalizer(Isolate* isolate, ObjectWeakCallbackState*
  * 		-ones called for the second or next time which are already weak in java too
  *	These objects are categorized by "regular" and "callback" and saved in different arrays for performance optimizations during GC
  * */
-void ObjectManager::JSObjectWeakCallback(Isolate* isolate, ObjectWeakCallbackState* callbackState) {
+void ObjectManager::JSObjectWeakCallback(Isolate *isolate, ObjectWeakCallbackState *callbackState) {
     HandleScope handleScope(isolate);
 
-    Persistent<Object>* po = callbackState->target;
+    Persistent<Object> *po = callbackState->target;
 
     auto itFound = m_visitedPOs.find(po);
 
@@ -337,24 +362,27 @@ void ObjectManager::JSObjectWeakCallback(Isolate* isolate, ObjectWeakCallbackSta
         m_visitedPOs.insert(po);
 
         auto obj = Local<Object>::New(isolate, *po);
-        JSInstanceInfo* jsInstanceInfo = GetJSInstanceInfo(obj);
-        int javaObjectID = jsInstanceInfo->JavaObjectID;
+        JSInstanceInfo *jsInstanceInfo = GetJSInstanceInfo(obj);
+
+        if(jsInstanceInfo != nullptr){
+            int javaObjectID = jsInstanceInfo->JavaObjectID;
 
-        bool hasImplObj = HasImplObject(isolate, obj);
+            bool hasImplObj = HasImplObject(isolate, obj);
 
-        DEBUG_WRITE("JSObjectWeakCallback objectId: %d, hasImplObj=%d", javaObjectID, hasImplObj);
+            DEBUG_WRITE("JSObjectWeakCallback objectId: %d, hasImplObj=%d", javaObjectID, hasImplObj);
 
-        if (hasImplObj) {
-            if (jsInstanceInfo->IsJavaObjectWeak) {
-                m_implObjWeak.push_back(PersistentObjectIdPair(po, javaObjectID));
+            if (hasImplObj) {
+                if (jsInstanceInfo->IsJavaObjectWeak) {
+                    m_implObjWeak.push_back(PersistentObjectIdPair(po, javaObjectID));
+                } else {
+                    m_implObjStrong.insert(make_pair(javaObjectID, po));
+                    jsInstanceInfo->IsJavaObjectWeak = true;
+                }
             } else {
-                m_implObjStrong.insert(make_pair(javaObjectID, po));
-                jsInstanceInfo->IsJavaObjectWeak = true;
+                assert(!m_markedForGC.empty());
+                auto &topGCInfo = m_markedForGC.top();
+                topGCInfo.markedForGC.push_back(po);
             }
-        } else {
-            assert(!m_markedForGC.empty());
-            auto& topGCInfo = m_markedForGC.top();
-            topGCInfo.markedForGC.push_back(po);
         }
     }
 
@@ -368,7 +396,7 @@ int ObjectManager::GenerateNewObjectID() {
     return oldValue;
 }
 
-void ObjectManager::ReleaseJSInstance(Persistent<Object>* po, JSInstanceInfo* jsInstanceInfo) {
+void ObjectManager::ReleaseJSInstance(Persistent<Object> *po, JSInstanceInfo *jsInstanceInfo) {
     int javaObjectID = jsInstanceInfo->JavaObjectID;
 
     auto it = m_idToObject.find(javaObjectID);
@@ -399,10 +427,11 @@ void ObjectManager::ReleaseRegularObjects() {
 
     HandleScope handleScope(m_isolate);
 
-    auto propName = String::NewFromUtf8(m_isolate, "t::gcNum", NewStringType::kNormal).ToLocalChecked();
+    auto propName = String::NewFromUtf8(m_isolate, "t::gcNum",
+                                        NewStringType::kNormal).ToLocalChecked();
 
-    auto& topGCInfo = m_markedForGC.top();
-    auto& marked = topGCInfo.markedForGC;
+    auto &topGCInfo = m_markedForGC.top();
+    auto &marked = topGCInfo.markedForGC;
     int numberOfGC = topGCInfo.numberOfGC;
 
     for (auto po : marked) {
@@ -420,13 +449,14 @@ void ObjectManager::ReleaseRegularObjects() {
         bool isReachableFromImplementationObject = false;
 
         if (!gcNum.IsEmpty()) {
-            int objGcNum = gcNum->Int32Value();
+            auto context = m_isolate->GetCurrentContext();
+            int objGcNum = gcNum->Int32Value(context).ToChecked();
 
             // done so we can release only java objects from this GC stack and pass all objects that will be released in parent GC stacks
             isReachableFromImplementationObject = objGcNum >= numberOfGC;
         }
 
-        JSInstanceInfo* jsInstanceInfo = GetJSInstanceInfo(obj);
+        JSInstanceInfo *jsInstanceInfo = GetJSInstanceInfo(obj);
 
         if (!isReachableFromImplementationObject) {
             if (!jsInstanceInfo->IsJavaObjectWeak) {
@@ -440,7 +470,7 @@ void ObjectManager::ReleaseRegularObjects() {
     marked.clear();
 }
 
-bool ObjectManager::HasImplObject(Isolate* isolate, const Local<Object>& obj) {
+bool ObjectManager::HasImplObject(Isolate *isolate, const Local<Object> &obj) {
     auto implObject = MetadataNode::GetImplementationObject(isolate, obj);
 
     bool hasImplObj = !implObject.IsEmpty();
@@ -452,7 +482,7 @@ bool ObjectManager::HasImplObject(Isolate* isolate, const Local<Object>& obj) {
  * When "MarkReachableObjects" is called V8 has marked all JS objects that can be released.
  * This method builds on top of V8s marking phase, because we need to consider the JAVA counterpart objects (is it "regular" or "callback"), when marking JS ones.
  * */
-void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>& obj) {
+void ObjectManager::MarkReachableObjects(Isolate *isolate, const Local<Object> &obj) {
     tns::instrumentation::Frame frame;
 
     stack<Local<Value>> s;
@@ -462,7 +492,7 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
     auto propName = String::NewFromUtf8(isolate, "t::gcNum");
 
     assert(!m_markedForGC.empty());
-    auto& topGCInfo = m_markedForGC.top();
+    auto &topGCInfo = m_markedForGC.top();
     int numberOfGC = topGCInfo.numberOfGC;
     auto fromJsInfo = GetJSInstanceInfo(obj);
     auto fromId = fromJsInfo->JavaObjectID;
@@ -488,7 +518,8 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
             if (itFound != m_visited.end()) {
                 continue;
             }
-            m_visited.insert(addr); // set as processed only if the current object is not the object we are starting from
+            m_visited.insert(
+                    addr); // set as processed only if the current object is not the object we are starting from
         }
 
         auto jsInfo = GetJSInstanceInfo(o);
@@ -508,9 +539,10 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
             auto func = o.As<Function>();
 
             int closureObjectLength;
-            auto closureObjects = NativeScriptExtension::GetClosureObjects(isolate, func, &closureObjectLength);
+            auto closureObjects = NativeScriptExtension::GetClosureObjects(isolate, func,
+                                                                           &closureObjectLength);
             for (int i = 0; i < closureObjectLength; i++) {
-                auto& curV = *(closureObjects + i);
+                auto &curV = *(closureObjects + i);
                 if (!curV.IsEmpty() && curV->IsObject()) {
                     s.push(curV);
                 }
@@ -545,9 +577,10 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
 
                     if (!getter.IsEmpty() && getter->IsFunction()) {
                         int getterClosureObjectLength = 0;
-                        auto getterClosureObjects = NativeScriptExtension::GetClosureObjects(isolate, getter.As<Function>(), &getterClosureObjectLength);
+                        auto getterClosureObjects = NativeScriptExtension::GetClosureObjects(
+                                isolate, getter.As<Function>(), &getterClosureObjectLength);
                         for (int i = 0; i < getterClosureObjectLength; i++) {
-                            auto& curV = *(getterClosureObjects + i);
+                            auto &curV = *(getterClosureObjects + i);
                             if (!curV.IsEmpty() && curV->IsObject()) {
                                 s.push(curV);
                             }
@@ -557,9 +590,10 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
 
                     if (!setter.IsEmpty() && setter->IsFunction()) {
                         int setterClosureObjectLength = 0;
-                        auto setterClosureObjects = NativeScriptExtension::GetClosureObjects(isolate, setter.As<Function>(), &setterClosureObjectLength);
+                        auto setterClosureObjects = NativeScriptExtension::GetClosureObjects(
+                                isolate, setter.As<Function>(), &setterClosureObjectLength);
                         for (int i = 0; i < setterClosureObjectLength; i++) {
-                            auto& curV = *(setterClosureObjects + i);
+                            auto &curV = *(setterClosureObjects + i);
                             if (!curV.IsEmpty() && curV->IsObject()) {
                                 s.push(curV);
                             }
@@ -586,7 +620,7 @@ void ObjectManager::MarkReachableObjects(Isolate* isolate, const Local<Object>&
     }
 }
 
-void ObjectManager::MarkReachableArrayElements(Local<Object>& o, stack<Local<Value>>& s) {
+void ObjectManager::MarkReachableArrayElements(Local<Object> &o, stack<Local<Value>> &s) {
     auto arr = o.As<Array>();
 
     int arrEnclosedObjectsLength = arr->Length();
@@ -599,12 +633,12 @@ void ObjectManager::MarkReachableArrayElements(Local<Object>& o, stack<Local<Val
     }
 }
 
-void ObjectManager::OnGcStartedStatic(Isolate* isolate, GCType type, GCCallbackFlags flags) {
+void ObjectManager::OnGcStartedStatic(Isolate *isolate, GCType type, GCCallbackFlags flags) {
     try {
         auto runtime = Runtime::GetRuntime(isolate);
         auto objectManager = runtime->GetObjectManager();
         objectManager->OnGcStarted(type, flags);
-    } catch (NativeScriptException& e) {
+    } catch (NativeScriptException &e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
         stringstream ss;
@@ -617,12 +651,12 @@ void ObjectManager::OnGcStartedStatic(Isolate* isolate, GCType type, GCCallbackF
     }
 }
 
-void ObjectManager::OnGcFinishedStatic(Isolate* isolate, GCType type, GCCallbackFlags flags) {
+void ObjectManager::OnGcFinishedStatic(Isolate *isolate, GCType type, GCCallbackFlags flags) {
     try {
         auto runtime = Runtime::GetRuntime(isolate);
         auto objectManager = runtime->GetObjectManager();
         objectManager->OnGcFinished(type, flags);
-    } catch (NativeScriptException& e) {
+    } catch (NativeScriptException &e) {
         e.ReThrowToV8();
     } catch (std::exception e) {
         stringstream ss;
@@ -654,8 +688,8 @@ void ObjectManager::OnGcFinished(GCType type, GCCallbackFlags flags) {
         auto obj = Local<Object>::New(isolate, *weakObj.po);
         MarkReachableObjects(isolate, obj);
     }
-    for (const auto& kv : m_implObjStrong) {
-        Persistent<Object>* po = kv.second;
+    for (const auto &kv : m_implObjStrong) {
+        Persistent<Object> *po = kv.second;
         if (po != nullptr) {
             auto obj = Local<Object>::New(isolate, *po);
             MarkReachableObjects(isolate, obj);
@@ -687,7 +721,7 @@ void ObjectManager::OnGcFinished(GCType type, GCCallbackFlags flags) {
  * We have all the JS "regular" objects that JS has made weak and ready to by GC'd,
  * so we tell java to take the JAVA objects out of strong reference so they can be collected by JAVA GC
  * */
-void ObjectManager::MakeRegularObjectsWeak(const set<int>& instances, DirectBuffer& inputBuff) {
+void ObjectManager::MakeRegularObjectsWeak(const set<int> &instances, DirectBuffer &inputBuff) {
     jboolean keepAsWeak = JNI_FALSE;
 
     for (auto javaObjectId : instances) {
@@ -695,7 +729,8 @@ void ObjectManager::MakeRegularObjectsWeak(const set<int>& instances, DirectBuff
 
         if (!success) {
             int length = inputBuff.Length();
-            m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID, (jobject) inputBuff, length, keepAsWeak);
+            m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID,
+                                 (jobject) inputBuff, length, keepAsWeak);
             inputBuff.Reset();
             success = inputBuff.Write(javaObjectId);
             assert(success);
@@ -703,7 +738,8 @@ void ObjectManager::MakeRegularObjectsWeak(const set<int>& instances, DirectBuff
     }
     int size = inputBuff.Size();
     if (size > 0) {
-        m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID, (jobject) inputBuff, size, keepAsWeak);
+        m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID,
+                             (jobject) inputBuff, size, keepAsWeak);
     }
 
     inputBuff.Reset();
@@ -714,10 +750,11 @@ void ObjectManager::MakeRegularObjectsWeak(const set<int>& instances, DirectBuff
  * so we tell java to take the JAVA objects out of strong, BUT KEEP THEM AS WEEK REFERENCES,
  * so that if java needs to release them, it can, on a later stage.
  * */
-void ObjectManager::MakeImplObjectsWeak(const map<int, Persistent<Object>*>& instances, DirectBuffer& inputBuff) {
+void ObjectManager::MakeImplObjectsWeak(const map<int, Persistent<Object> *> &instances,
+                                        DirectBuffer &inputBuff) {
     jboolean keepAsWeak = JNI_TRUE;
 
-    for (const auto& kv : instances) {
+    for (const auto &kv : instances) {
         if (kv.second != nullptr) {
             int javaObjectId = kv.first;
 
@@ -726,7 +763,8 @@ void ObjectManager::MakeImplObjectsWeak(const map<int, Persistent<Object>*>& ins
             if (!success) {
                 int length = inputBuff.Length();
                 jboolean keepAsWeak = JNI_TRUE;
-                m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID, (jobject) inputBuff, length, keepAsWeak);
+                m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID,
+                                     (jobject) inputBuff, length, keepAsWeak);
                 inputBuff.Reset();
                 success = inputBuff.Write(javaObjectId);
                 assert(success);
@@ -736,7 +774,8 @@ void ObjectManager::MakeImplObjectsWeak(const map<int, Persistent<Object>*>& ins
     int size = inputBuff.Size();
     if (size > 0) {
         jboolean keepAsWeak = JNI_TRUE;
-        m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID, (jobject) inputBuff, size, keepAsWeak);
+        m_env.CallVoidMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_BATCH_METHOD_ID,
+                             (jobject) inputBuff, size, keepAsWeak);
     }
 
     inputBuff.Reset();
@@ -746,24 +785,26 @@ void ObjectManager::MakeImplObjectsWeak(const map<int, Persistent<Object>*>& ins
  * Consult with JAVA world to check if a java object is still in kept as a strong or weak reference
  * If the JAVA objects are released, we can release the their counterpart JS objects
  * */
-void ObjectManager::CheckWeakObjectsAreAlive(const vector<PersistentObjectIdPair>& instances, DirectBuffer& inputBuff, DirectBuffer& outputBuff) {
+void ObjectManager::CheckWeakObjectsAreAlive(const vector<PersistentObjectIdPair> &instances,
+                                             DirectBuffer &inputBuff, DirectBuffer &outputBuff) {
     TNSPERF();
 
-    for (const auto& poIdPair : instances) {
+    for (const auto &poIdPair : instances) {
         int javaObjectId = poIdPair.javaObjectId;
 
         bool success = inputBuff.Write(javaObjectId);
 
         if (!success) {
             int length = inputBuff.Length();
-            m_env.CallVoidMethod(m_javaRuntimeObject, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID, (jobject) inputBuff, (jobject) outputBuff, length);
+            m_env.CallVoidMethod(m_javaRuntimeObject, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID,
+                                 (jobject) inputBuff, (jobject) outputBuff, length);
             //
-            int* released = outputBuff.GetData();
+            int *released = outputBuff.GetData();
             for (int i = 0; i < length; i++) {
                 bool isReleased = *released++ != 0;
 
                 if (isReleased) {
-                    Persistent<Object>* po = instances[i].po;
+                    Persistent<Object> *po = instances[i].po;
                     po->Reset();
                 }
             }
@@ -775,21 +816,22 @@ void ObjectManager::CheckWeakObjectsAreAlive(const vector<PersistentObjectIdPair
     }
     int size = inputBuff.Size();
     if (size > 0) {
-        m_env.CallVoidMethod(m_javaRuntimeObject, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID, (jobject) inputBuff, (jobject) outputBuff, size);
-        int* released = outputBuff.GetData();
+        m_env.CallVoidMethod(m_javaRuntimeObject, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID,
+                             (jobject) inputBuff, (jobject) outputBuff, size);
+        int *released = outputBuff.GetData();
         for (int i = 0; i < size; i++) {
             bool isReleased = *released++ != 0;
 
             if (isReleased) {
-                Persistent<Object>* po = instances[i].po;
+                Persistent<Object> *po = instances[i].po;
                 po->Reset();
             }
         }
     }
 }
 
-jweak ObjectManager::NewWeakGlobalRefCallback(const int& javaObjectID, void* state) {
-    auto objManager = reinterpret_cast<ObjectManager*>(state);
+jweak ObjectManager::NewWeakGlobalRefCallback(const int &javaObjectID, void *state) {
+    auto objManager = reinterpret_cast<ObjectManager *>(state);
 
     JniLocalRef obj(objManager->GetJavaObjectByIDImpl(javaObjectID));
 
@@ -798,13 +840,13 @@ jweak ObjectManager::NewWeakGlobalRefCallback(const int& javaObjectID, void* sta
     return weakRef;
 }
 
-void ObjectManager::DeleteWeakGlobalRefCallback(const jweak& object, void* state) {
-    auto objManager = reinterpret_cast<ObjectManager*>(state);
+void ObjectManager::DeleteWeakGlobalRefCallback(const jweak &object, void *state) {
+    auto objManager = reinterpret_cast<ObjectManager *>(state);
 
     objManager->m_env.DeleteWeakGlobalRef(object);
 }
 
-Local<Object> ObjectManager::GetEmptyObject(Isolate* isolate) {
+Local<Object> ObjectManager::GetEmptyObject(Isolate *isolate) {
     auto emptyObjCtorFunc = Local<Function>::New(isolate, *m_poJsWrapperFunc);
     auto val = emptyObjCtorFunc->CallAsConstructor(isolate->GetCurrentContext(), 0, nullptr);
     if (val.IsEmpty()) {
@@ -816,6 +858,26 @@ Local<Object> ObjectManager::GetEmptyObject(Isolate* isolate) {
     return obj;
 }
 
-void ObjectManager::JSWrapperConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
+void ObjectManager::JSWrapperConstructorCallback(const v8::FunctionCallbackInfo<v8::Value> &info) {
     assert(info.IsConstructCall());
 }
+
+void ObjectManager::ReleaseNativeCounterpart(v8::Local<v8::Object> &object) {
+
+    if(!object->IsObject()){
+        throw NativeScriptException("Argument is not an object!");
+    }
+
+    JSInstanceInfo *jsInstanceInfo = GetJSInstanceInfo(object);
+
+    if(jsInstanceInfo == nullptr){
+        throw NativeScriptException("Trying to release a non native object!");
+    }
+
+    m_env.CallVoidMethod(m_javaRuntimeObject, RELEASE_NATIVE_INSTANCE_METHOD_ID,
+                         jsInstanceInfo->JavaObjectID);
+
+    delete jsInstanceInfo;
+    auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
+    object->SetInternalField(jsInfoIdx, Undefined(m_isolate));
+}
diff --git a/test-app/runtime/src/main/cpp/ObjectManager.h b/test-app/runtime/src/main/cpp/ObjectManager.h
index b3f50c4c7..16a3e0768 100644
--- a/test-app/runtime/src/main/cpp/ObjectManager.h
+++ b/test-app/runtime/src/main/cpp/ObjectManager.h
@@ -37,8 +37,12 @@ class ObjectManager {
 
         void Link(const v8::Local<v8::Object>& object, uint32_t javaObjectID, jclass clazz);
 
+        void ReleaseNativeCounterpart(v8::Local<v8::Object>& object);
+
         bool CloneLink(const v8::Local<v8::Object>& src, const v8::Local<v8::Object>& dest);
 
+        bool IsJsRuntimeObject(const v8::Local<v8::Object>& object);
+
         std::string GetClassName(jobject javaObject);
 
         std::string GetClassName(jclass clazz);
@@ -139,7 +143,7 @@ class ObjectManager {
             int javaObjectId;
         };
 
-        bool IsJsRuntimeObject(const v8::Local<v8::Object>& object);
+
 
         JSInstanceInfo* GetJSInstanceInfo(const v8::Local<v8::Object>& object);
 
@@ -231,6 +235,8 @@ class ObjectManager {
 
         jmethodID MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID;
 
+        jmethodID RELEASE_NATIVE_INSTANCE_METHOD_ID;
+
         jmethodID CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID;
 
         v8::Persistent<v8::Function>* m_poJsWrapperFunc;
diff --git a/test-app/runtime/src/main/cpp/Profiler.cpp b/test-app/runtime/src/main/cpp/Profiler.cpp
index b71883eb2..e92ab0142 100644
--- a/test-app/runtime/src/main/cpp/Profiler.cpp
+++ b/test-app/runtime/src/main/cpp/Profiler.cpp
@@ -45,7 +45,7 @@ void Profiler::StartCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::V
     auto isolate = args.GetIsolate();
     auto started = false;
     if ((args.Length() == 1) && (args[0]->IsString())) {
-        auto name = args[0]->ToString();
+        auto name = args[0]->ToString(isolate);
         StartCPUProfiler(isolate, name);
         started = true;
     }
@@ -75,7 +75,7 @@ void Profiler::StopCPUProfilerCallbackImpl(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto stopped = false;
     if ((args.Length() == 1) && (args[0]->IsString())) {
-        auto name = args[0]->ToString();
+        auto name = args[0]->ToString(isolate);
         stopped = StopCPUProfiler(isolate, name);
     }
     args.GetReturnValue().Set(stopped);
diff --git a/test-app/runtime/src/main/cpp/Runtime.cpp b/test-app/runtime/src/main/cpp/Runtime.cpp
index 286215dfa..3be05ace6 100644
--- a/test-app/runtime/src/main/cpp/Runtime.cpp
+++ b/test-app/runtime/src/main/cpp/Runtime.cpp
@@ -31,6 +31,7 @@
 
 #ifdef APPLICATION_IN_DEBUG
 #include "JsV8InspectorClient.h"
+#include "v8_inspector/src/inspector/v8-inspector-platform.h"
 #endif
 
 using namespace v8;
@@ -45,8 +46,7 @@ void SIGABRT_handler(int sigNumber) {
 }
 
 void Runtime::Init(JavaVM* vm, void* reserved) {
-    __android_log_print(ANDROID_LOG_INFO, "TNS.Native", "NativeScript Runtime Version %s, commit %s", NATIVE_SCRIPT_RUNTIME_VERSION, NATIVE_SCRIPT_RUNTIME_COMMIT_SHA);
-    DEBUG_WRITE("JNI_ONLoad");
+    __android_log_print(ANDROID_LOG_INFO, "TNS.Runtime", "NativeScript Runtime Version %s, commit %s", NATIVE_SCRIPT_RUNTIME_VERSION, NATIVE_SCRIPT_RUNTIME_COMMIT_SHA);
 
     if (Runtime::s_jvm == nullptr) {
         s_jvm = vm;
@@ -60,8 +60,6 @@ void Runtime::Init(JavaVM* vm, void* reserved) {
         action.sa_handler = SIGABRT_handler;
         sigaction(SIGABRT, &action, NULL);
     }
-
-    DEBUG_WRITE("JNI_ONLoad END");
 }
 
 int Runtime::GetAndroidVersion() {
@@ -183,7 +181,7 @@ void Runtime::Init(jstring filesPath, jstring nativeLibDir, bool verboseLoggingE
 
     auto profilerOutputDirStr = ArgConverter::jstringToString(profilerOutputDir);
 
-    NativeScriptException::Init(m_objectManager);
+    NativeScriptException::Init();
     m_isolate = PrepareV8Runtime(filesRoot, nativeLibDirStr, packageNameStr, isDebuggable, callingDirStr, profilerOutputDirStr, maxLogcatObjectSize, forceLog);
 
     s_isolate2RuntimesCache.insert(make_pair(m_isolate, this));
@@ -370,11 +368,13 @@ bool Runtime::TryCallGC() {
     return success;
 }
 
-void Runtime::PassUncaughtExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable exception, jstring stackTrace) {
+void Runtime::PassExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable exception, jstring stackTrace, jboolean isDiscarded) {
     auto isolate = m_isolate;
 
     //create error message
-    string errMsg = "The application crashed because of an uncaught exception. You can look at \"stackTrace\" or \"nativeException\" for more detailed information about the exception.";
+    string errMsg = isDiscarded ? "An exception was caught and discarded. You can look at \"stackTrace\" or \"nativeException\" for more detailed information about the exception.":
+                    "The application crashed because of an uncaught exception. You can look at \"stackTrace\" or \"nativeException\" for more detailed information about the exception.";
+
     auto errObj = Exception::Error(ArgConverter::ConvertToV8String(isolate, errMsg)).As<Object>();
 
     //create a new native exception js object
@@ -398,7 +398,7 @@ void Runtime::PassUncaughtExceptionToJsNative(JNIEnv* env, jobject obj, jthrowab
     errObj->Set(V8StringConstants::GetStackTrace(isolate), ArgConverter::jstringToV8String(isolate, stackTrace));
 
     //pass err to JS
-    NativeScriptException::CallJsFuncWithErr(errObj);
+    NativeScriptException::CallJsFuncWithErr(errObj, isDiscarded);
 }
 
 void Runtime::PassUncaughtExceptionFromWorkerToMainHandler(Local<v8::String> message, Local<v8::String> stackTrace, Local<v8::String> filename, int lineno) {
@@ -425,7 +425,18 @@ void Runtime::ClearStartupData(JNIEnv* env, jobject obj) {
 }
 
 static void InitializeV8() {
-    Runtime::platform = v8::platform::CreateDefaultPlatform();
+    Runtime::platform =
+#ifdef APPLICATION_IN_DEBUG
+        // The default V8 platform isn't Chrome DevTools compatible. The frontend uses the
+        // Runtime.evaluate protocol command with timeout flag for every execution in the console.
+        // The default platform doesn't implement executing delayed javascript code from a background
+        // thread. To avoid implementing a full blown scheduler, we use the default platform with a
+        // timeout=0 flag.
+        V8InspectorPlatform::CreateDefaultPlatform();
+#else
+        v8::platform::CreateDefaultPlatform();
+#endif
+
     V8::InitializePlatform(Runtime::platform);
     V8::Initialize();
 }
@@ -465,6 +476,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
     if (snapshotPtr) {
         m_startupData->data = static_cast<const char*>(dlsym(snapshotPtr, "TNSSnapshot_blob"));
         m_startupData->raw_size = *static_cast<const unsigned int*>(dlsym(snapshotPtr, "TNSSnapshot_blob_len"));
+        create_params.snapshot_blob = m_startupData;
         DEBUG_WRITE_FORCE("Snapshot library read %p (%dB).", m_startupData->data, m_startupData->raw_size);
     } else if (!Constants::V8_HEAP_SNAPSHOT_BLOB.empty() || !Constants::V8_HEAP_SNAPSHOT_SCRIPT.empty()) {
         DEBUG_WRITE_FORCE("Snapshot enabled.");
@@ -502,7 +514,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
             }
 
             DEBUG_WRITE_FORCE("Creating heap snapshot");
-            *m_startupData = V8::CreateSnapshotDataBlob(customScript.c_str());
+            *m_startupData = Runtime::CreateSnapshotDataBlob(customScript.c_str());
 
             if (m_startupData->raw_size == 0) {
                 DEBUG_WRITE_FORCE("Failed to create heap snapshot.");
@@ -548,7 +560,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
 
     isolate->AddMessageListener(NativeScriptException::OnUncaughtError);
 
-    __android_log_print(ANDROID_LOG_DEBUG, "TNS.Native", "V8 version %s", V8::GetVersion());
+    __android_log_print(ANDROID_LOG_DEBUG, "TNS.Runtime", "V8 version %s", V8::GetVersion());
 
     auto globalFunctionTemplate = FunctionTemplate::New(isolate);
     globalFunctionTemplate->SetClassName(ArgConverter::ConvertToV8String(isolate, "NativeScriptGlobalObject"));
@@ -563,6 +575,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
     globalTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__exit"), FunctionTemplate::New(isolate, CallbackHandlers::ExitMethodCallback));
     globalTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__runtimeVersion"), ArgConverter::ConvertToV8String(isolate, NATIVE_SCRIPT_RUNTIME_VERSION), readOnlyFlags);
     globalTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__time"), FunctionTemplate::New(isolate, CallbackHandlers::TimeCallback));
+    globalTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__releaseNativeCounterpart"), FunctionTemplate::New(isolate, CallbackHandlers::ReleaseNativeCounterpartCallback));
 
     /*
      * Attach `Worker` object constructor only to the main thread (isolate)'s global object
@@ -618,7 +631,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
 
     auto global = context->Global();
 
-    auto gcFunc = global->Get(ConvertToV8String("gc"));
+    auto gcFunc = global->Get(ArgConverter::ConvertToV8String(isolate, "gc"));
     if (!gcFunc.IsEmpty() && gcFunc->IsFunction()) {
         m_gcFunc = new Persistent<Function>(isolate, gcFunc.As<Function>());
     }
@@ -685,6 +698,60 @@ void Runtime::SetManualInstrumentationMode(jstring mode) {
     }
 }
 
+StartupData Runtime::CreateSnapshotDataBlob(const char* embedded_source) {
+    // Create a new isolate and a new context from scratch, optionally run
+    // a script to embed, and serialize to create a snapshot blob.
+    StartupData result = {nullptr, 0};
+    {
+        SnapshotCreator snapshot_creator;
+        Isolate* isolate = snapshot_creator.GetIsolate();
+        {
+            HandleScope scope(isolate);
+            Local<Context> context = Context::New(isolate);
+            if (embedded_source != nullptr &&
+                    !Runtime::RunExtraCode(isolate, context, embedded_source, "<embedded>")) {
+                return result;
+            }
+            snapshot_creator.SetDefaultContext(context);
+        }
+        result = snapshot_creator.CreateBlob(
+                     SnapshotCreator::FunctionCodeHandling::kClear);
+    }
+
+    return result;
+}
+
+bool Runtime::RunExtraCode(Isolate* isolate, Local<Context> context, const char* utf8_source, const char* name) {
+    Context::Scope context_scope(context);
+    TryCatch try_catch(isolate);
+    Local<v8::String> source_string;
+    if (!v8::String::NewFromUtf8(isolate, utf8_source, NewStringType::kNormal).ToLocal(&source_string)) {
+        return false;
+    }
+    Local<v8::String> resource_name = v8::String::NewFromUtf8(isolate, name, NewStringType::kNormal).ToLocalChecked();
+    ScriptOrigin origin(resource_name);
+    ScriptCompiler::Source source(source_string, origin);
+    Local<Script> script;
+    if (!ScriptCompiler::Compile(context, &source).ToLocal(&script)) {
+        DEBUG_WRITE_FORCE("# Script compile failed in %s@%d:%d\n%s\n",
+                          *v8::String::Utf8Value(isolate, try_catch.Message()->GetScriptResourceName()),
+                          try_catch.Message()->GetLineNumber(context).FromJust(),
+                          try_catch.Message()->GetStartColumn(context).FromJust(),
+                          *v8::String::Utf8Value(isolate, try_catch.Exception()));
+        return false;
+    }
+    if (script->Run(context).IsEmpty()) {
+        DEBUG_WRITE_FORCE("# Script run failed in %s@%d:%d\n%s\n",
+                          *v8::String::Utf8Value(isolate, try_catch.Message()->GetScriptResourceName()),
+                          try_catch.Message()->GetLineNumber(context).FromJust(),
+                          try_catch.Message()->GetStartColumn(context).FromJust(),
+                          *v8::String::Utf8Value(isolate, try_catch.Exception()));
+        return false;
+    }
+    CHECK(!try_catch.HasCaught());
+    return true;
+}
+
 void Runtime::DestroyRuntime() {
     s_id2RuntimeCache.erase(m_id);
     s_isolate2RuntimesCache.erase(m_isolate);
diff --git a/test-app/runtime/src/main/cpp/Runtime.h b/test-app/runtime/src/main/cpp/Runtime.h
index 8f8cdffe7..9884240c2 100644
--- a/test-app/runtime/src/main/cpp/Runtime.h
+++ b/test-app/runtime/src/main/cpp/Runtime.h
@@ -52,7 +52,7 @@ class Runtime {
         void AdjustAmountOfExternalAllocatedMemory();
         bool NotifyGC(JNIEnv* env, jobject obj);
         bool TryCallGC();
-        void PassUncaughtExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable exception, jstring stackTrace);
+        void PassExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable exception, jstring stackTrace, jboolean isDiscarded);
         void PassUncaughtExceptionFromWorkerToMainHandler(v8::Local<v8::String> message, v8::Local<v8::String> stackTrace, v8::Local<v8::String> filename, int lineno);
         void ClearStartupData(JNIEnv* env, jobject obj);
         void DestroyRuntime();
@@ -92,6 +92,8 @@ class Runtime {
 
         v8::Isolate* PrepareV8Runtime(const std::string& filesPath, const std::string& nativeLibsDir, const std::string& packageName, bool isDebuggable, const std::string& callingDir, const std::string& profilerOutputDir, const int maxLogcatObjectSize, const bool forceLog);
         jobject ConvertJsValueToJavaObject(JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
+        static v8::StartupData CreateSnapshotDataBlob(const char* embedded_source);
+        static bool RunExtraCode(v8::Isolate* isolate, v8::Local<v8::Context> context, const char* utf8_source, const char* name);
         static int GetAndroidVersion();
         static int m_androidVersion;
 
diff --git a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
index 03b901169..8a93c6c90 100644
--- a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
+++ b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
@@ -11,15 +11,6 @@ using namespace std;
 
 static std::map<v8::Isolate*, v8::Persistent<v8::Function>*> isolateToPersistentSmartJSONStringify = std::map<v8::Isolate*, v8::Persistent<v8::Function>*>();
 
-string tns::ConvertToString(const Local<v8::String>& s) {
-    if (s.IsEmpty()) {
-        return string();
-    } else {
-        String::Utf8Value str(s);
-        return string(*str);
-    }
-}
-
 Local<Function> GetSmartJSONStringifyFunction(Isolate* isolate) {
     auto it = isolateToPersistentSmartJSONStringify.find(isolate);
     if (it != isolateToPersistentSmartJSONStringify.end()) {
@@ -87,11 +78,11 @@ Local<String> tns::JsonStringifyObject(Isolate* isolate, Handle<v8::Value> value
             v8::Local<v8::Value> resultValue;
             v8::TryCatch tc(isolate);
 
-            Local<Value> args[] = { value->ToObject() };
+            Local<Value> args[] = { value->ToObject(isolate) };
             auto success = smartJSONStringifyFunction->Call(isolate->GetCurrentContext(), Undefined(isolate), 1, args).ToLocal(&resultValue);
 
             if (success && !tc.HasCaught()) {
-                return resultValue->ToString();
+                return resultValue->ToString(isolate);
             }
         }
     }
@@ -102,60 +93,12 @@ Local<String> tns::JsonStringifyObject(Isolate* isolate, Handle<v8::Value> value
 
     if (!success && tc.HasCaught()) {
         auto message = tc.Message()->Get();
-        resultString = v8::String::Concat(ArgConverter::ConvertToV8String(isolate, "Couldn't convert object to a JSON string: "), message);
+        resultString = v8::String::Concat(isolate, ArgConverter::ConvertToV8String(isolate, "Couldn't convert object to a JSON string: "), message);
     }
 
     return resultString;
 }
 
-jstring tns::ConvertToJavaString(const Local<Value>& value) {
-    JEnv env;
-    String::Value stringValue(value);
-    return env.NewString((const jchar*) *stringValue, stringValue.length());
-}
-
-Local<String> tns::ConvertToV8String(const jchar* data, int length) {
-    auto isolate = Isolate::GetCurrent();
-    return String::NewFromTwoByte(isolate, (const uint16_t*) data, String::kNormalString, length);
-}
-
-Local<String> tns::ConvertToV8String(const string& s) {
-    auto isolate = Isolate::GetCurrent();
-    Local<v8::String> str = String::NewFromUtf8(isolate, s.c_str(), NewStringType::kNormal, s.length()).ToLocalChecked();
-    return str;
-}
-
-Local<String> tns::ConvertToV8String(const char* data, int length) {
-    auto isolate = Isolate::GetCurrent();
-    return String::NewFromUtf8(isolate, (const char*) data, String::kNormalString, length);
-}
-
-bool tns::V8HasPrivateValue(Isolate* isolate, const Local<Object>& obj, const Local<String>& propName) {
-
-    if (obj.IsEmpty()) {
-        return false;
-    }
-
-    auto privateKey = Private::ForApi(isolate, propName);
-
-    auto hasPrivate = obj->HasPrivate(isolate->GetCurrentContext(), privateKey);
-
-    if (hasPrivate.IsNothing()) {
-        return false;
-    }
-
-    if (!hasPrivate.FromMaybe(false)) {
-        return false;
-    }
-
-    auto res = obj->GetPrivate(isolate->GetCurrentContext(), privateKey);
-    if (res.IsEmpty()) {
-        return false;
-    }
-
-    return true;
-}
-
 bool tns::V8GetPrivateValue(Isolate* isolate, const Local<Object>& obj, const Local<String>& propName, Local<Value>& out) {
     auto privateKey = Private::ForApi(isolate, propName);
 
@@ -163,7 +106,7 @@ bool tns::V8GetPrivateValue(Isolate* isolate, const Local<Object>& obj, const Lo
 
     if (hasPrivate.IsNothing()) {
         stringstream ss;
-        ss << "Failed to Get Private Value for prop: " << tns::ConvertToString(propName).c_str() << endl;
+        ss << "Failed to Get Private Value for prop: " << ArgConverter::ConvertToString(propName).c_str() << endl;
         throw tns::NativeScriptException(ss.str());
     }
 
@@ -175,7 +118,7 @@ bool tns::V8GetPrivateValue(Isolate* isolate, const Local<Object>& obj, const Lo
 
     if (res.IsEmpty()) {
         stringstream ss;
-        ss << "Failed to Get Private Value for prop: " << tns::ConvertToString(propName).c_str() << endl;
+        ss << "Failed to Get Private Value for prop: " << ArgConverter::ConvertToString(propName).c_str() << endl;
         throw tns::NativeScriptException(ss.str());
     }
 
@@ -188,7 +131,7 @@ bool tns::V8SetPrivateValue(Isolate* isolate, const Local<Object>& obj, const Lo
 
     if (res.IsNothing()) {
         stringstream ss;
-        ss << "Failed to Set Private Value for prop: " << tns::ConvertToString(propName).c_str() << endl;
+        ss << "Failed to Set Private Value for prop: " << ArgConverter::ConvertToString(propName).c_str() << endl;
         throw tns::NativeScriptException(ss.str());
     }
 
diff --git a/test-app/runtime/src/main/cpp/V8GlobalHelpers.h b/test-app/runtime/src/main/cpp/V8GlobalHelpers.h
index cff884268..701c171d5 100644
--- a/test-app/runtime/src/main/cpp/V8GlobalHelpers.h
+++ b/test-app/runtime/src/main/cpp/V8GlobalHelpers.h
@@ -8,20 +8,8 @@
 #include <map>
 
 namespace tns {
-std::string ConvertToString(const v8::Local<v8::String>& s);
-
 v8::Local<v8::String> JsonStringifyObject(v8::Isolate* isolate, v8::Handle<v8::Value> value);
 
-jstring ConvertToJavaString(const v8::Local<v8::Value>& jsValue);
-
-v8::Local<v8::String> ConvertToV8String(const jchar* data, int length);
-
-v8::Local<v8::String> ConvertToV8String(const std::string& s);
-
-v8::Local<v8::String> ConvertToV8String(const char* data, int length);
-
-bool V8HasPrivateValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName);
-
 bool V8GetPrivateValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName, v8::Local<v8::Value>& out);
 
 bool V8SetPrivateValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName, const v8::Local<v8::Value>& value);
diff --git a/test-app/runtime/src/main/cpp/V8StringConstants.cpp b/test-app/runtime/src/main/cpp/V8StringConstants.cpp
index e6a52fd18..4dc909f2d 100644
--- a/test-app/runtime/src/main/cpp/V8StringConstants.cpp
+++ b/test-app/runtime/src/main/cpp/V8StringConstants.cpp
@@ -111,6 +111,12 @@ Local<String> V8StringConstants::GetUncaughtError(Isolate* isolate) {
     return Local<String>::New(isolate, *consts->UNCAUGHT_ERROR_PERSISTENT);
 }
 
+Local<String> V8StringConstants::GetDiscardedError(Isolate* isolate) {
+    auto consts = GetConstantsForIsolate(isolate);
+
+    return Local<String>::New(isolate, *consts->DISCARDED_ERROR_PERSISTENT);
+}
+
 Local<String> V8StringConstants::GetImplementationObject(Isolate* isolate) {
     auto consts = GetConstantsForIsolate(isolate);
 
@@ -133,5 +139,6 @@ const string V8StringConstants::JAVA_LONG = "t::JavaLong";
 const string V8StringConstants::VALUE = "value";
 const string V8StringConstants::VALUE_OF = "valueOf";
 const string V8StringConstants::UNCAUGHT_ERROR = "__onUncaughtError";
+const string V8StringConstants::DISCARDED_ERROR = "__onDiscardedError";
 const string V8StringConstants::IMPLEMENTATION_OBJECT = "t::implObj";
 }
diff --git a/test-app/runtime/src/main/cpp/V8StringConstants.h b/test-app/runtime/src/main/cpp/V8StringConstants.h
index 4687db651..7d88c9504 100644
--- a/test-app/runtime/src/main/cpp/V8StringConstants.h
+++ b/test-app/runtime/src/main/cpp/V8StringConstants.h
@@ -41,6 +41,8 @@ class V8StringConstants {
 
         static v8::Local<v8::String> GetUncaughtError(v8::Isolate* isolate);
 
+        static v8::Local<v8::String> GetDiscardedError(v8::Isolate* isolate);
+
         static v8::Local<v8::String> GetImplementationObject(v8::Isolate* isolate);
 
         static const std::string CLASS_IMPLEMENTATION_OBJECT;
@@ -60,6 +62,7 @@ class V8StringConstants {
         static const std::string VALUE_OF;
         static const std::string VALUE;
         static const std::string UNCAUGHT_ERROR;
+        static const std::string DISCARDED_ERROR;
         static const std::string IMPLEMENTATION_OBJECT;
 
         /*
@@ -133,6 +136,9 @@ class V8StringConstants {
                 str = String::NewFromUtf8(isolate, UNCAUGHT_ERROR.c_str());
                 UNCAUGHT_ERROR_PERSISTENT = new Persistent<String>(isolate, str);
 
+                str = String::NewFromUtf8(isolate, DISCARDED_ERROR.c_str());
+                DISCARDED_ERROR_PERSISTENT = new Persistent<String>(isolate, str);
+
                 str = String::NewFromUtf8(isolate, IMPLEMENTATION_OBJECT.c_str());
                 IMPLEMENTATION_OBJECT_PERSISTENT = new Persistent<String>(isolate, str);
             };
@@ -175,6 +181,7 @@ class V8StringConstants {
             v8::Persistent<v8::String>* VALUE_OF_PERSISTENT;
             v8::Persistent<v8::String>* VALUE_PERSISTENT;
             v8::Persistent<v8::String>* UNCAUGHT_ERROR_PERSISTENT;
+            v8::Persistent<v8::String>* DISCARDED_ERROR_PERSISTENT;
             v8::Persistent<v8::String>* IMPLEMENTATION_OBJECT_PERSISTENT;
         };
 
diff --git a/test-app/runtime/src/main/cpp/com_tns_AndroidJsV8Inspector.cpp b/test-app/runtime/src/main/cpp/com_tns_AndroidJsV8Inspector.cpp
index c4944e9be..cdef52e62 100644
--- a/test-app/runtime/src/main/cpp/com_tns_AndroidJsV8Inspector.cpp
+++ b/test-app/runtime/src/main/cpp/com_tns_AndroidJsV8Inspector.cpp
@@ -12,6 +12,7 @@ JNIEXPORT extern "C" void Java_com_tns_AndroidJsV8Inspector_init(JNIEnv* env, jo
 }
 
 JNIEXPORT extern "C" void Java_com_tns_AndroidJsV8Inspector_connect(JNIEnv* env, jobject instance, jobject connection) {
+    JsV8InspectorClient::GetInstance()->disconnect();
     JsV8InspectorClient::GetInstance()->connect(connection);
 }
 
diff --git a/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp b/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp
index b51ad4099..21786b809 100644
--- a/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp
+++ b/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp
@@ -245,7 +245,7 @@ extern "C" JNIEXPORT void Java_com_tns_Runtime_unlock(JNIEnv* env, jobject obj,
     }
 }
 
-extern "C" JNIEXPORT void Java_com_tns_Runtime_passUncaughtExceptionToJsNative(JNIEnv* env, jobject obj, jint runtimeId, jthrowable exception, jstring stackTrace) {
+extern "C" JNIEXPORT void Java_com_tns_Runtime_passExceptionToJsNative(JNIEnv* env, jobject obj, jint runtimeId, jthrowable exception, jstring stackTrace, jboolean isDiscarded) {
     auto runtime = TryGetRuntime(runtimeId);
     if (runtime == nullptr) {
         return;
@@ -256,7 +256,7 @@ extern "C" JNIEXPORT void Java_com_tns_Runtime_passUncaughtExceptionToJsNative(J
     v8::HandleScope handleScope(isolate);
 
     try {
-        runtime->PassUncaughtExceptionToJsNative(env, obj, exception, stackTrace);
+        runtime->PassExceptionToJsNative(env, obj, exception, stackTrace, isDiscarded);
     } catch (NativeScriptException& e) {
         e.ReThrowToJava();
     } catch (std::exception e) {
diff --git a/test-app/runtime/src/main/cpp/console/Console.cpp b/test-app/runtime/src/main/cpp/console/Console.cpp
index dab68ad4e..a6f63fff6 100644
--- a/test-app/runtime/src/main/cpp/console/Console.cpp
+++ b/test-app/runtime/src/main/cpp/console/Console.cpp
@@ -95,7 +95,7 @@ const v8::Local<v8::String> buildStringFromArg(v8::Isolate* isolate, const v8::L
         val->ToDetailString(isolate->GetCurrentContext()).ToLocal(&argString);
     } else if (val->IsArray()) {
         auto cachedSelf = val;
-        auto array = val->ToObject();
+        auto array = val->ToObject(isolate);
         auto arrayEntryKeys = array->GetPropertyNames(isolate->GetCurrentContext()).ToLocalChecked();
         auto context = isolate->GetCurrentContext();
 
@@ -110,20 +110,20 @@ const v8::Local<v8::String> buildStringFromArg(v8::Isolate* isolate, const v8::L
 
             // avoid bottomless recursion with cyclic reference to the same array
             if (propertyValue->StrictEquals(cachedSelf)) {
-                argString = v8::String::Concat(argString, ArgConverter::ConvertToV8String(isolate, "[Circular]"));
+                argString = v8::String::Concat(isolate, argString, ArgConverter::ConvertToV8String(isolate, "[Circular]"));
                 continue;
             }
 
             auto objectString = buildStringFromArg(isolate, propertyValue);
 
-            argString = v8::String::Concat(argString, objectString);
+            argString = v8::String::Concat(isolate, argString, objectString);
 
             if (i != arrayLength - 1) {
-                argString = v8::String::Concat(argString, ArgConverter::ConvertToV8String(isolate, ", "));
+                argString = v8::String::Concat(isolate, argString, ArgConverter::ConvertToV8String(isolate, ", "));
             }
         }
 
-        argString = v8::String::Concat(argString, ArgConverter::ConvertToV8String(isolate, "]"));
+        argString = v8::String::Concat(isolate, argString, ArgConverter::ConvertToV8String(isolate, "]"));
     } else if (val->IsObject()) {
         v8::Local<v8::Object> obj = val.As<v8::Object>();
 
@@ -173,7 +173,8 @@ void Console::assertCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
         auto isolate = info.GetIsolate();
 
         auto argLen = info.Length();
-        auto expressionPasses = argLen && info[0]->BooleanValue();
+        auto context = isolate->GetCurrentContext();
+        auto expressionPasses = argLen && info[0]->BooleanValue(context).ToChecked();
 
         if (!expressionPasses) {
             std::stringstream assertionError;
@@ -433,7 +434,7 @@ void Console::traceCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
         auto framesCount = stack->GetFrameCount();
 
         for (int i = 0; i < framesCount; i++) {
-            auto frame = stack->GetFrame(i);
+            auto frame = stack->GetFrame(isolate, i);
 
             ss << buildStacktraceFrameMessage(frame) << std::endl;
         }
diff --git a/test-app/runtime/src/main/cpp/include/libplatform/libplatform.h b/test-app/runtime/src/main/cpp/include/libplatform/libplatform.h
index 22713cbed..4c2c37143 100644
--- a/test-app/runtime/src/main/cpp/include/libplatform/libplatform.h
+++ b/test-app/runtime/src/main/cpp/include/libplatform/libplatform.h
@@ -62,11 +62,6 @@ V8_PLATFORM_EXPORT bool PumpMessageLoop(
     v8::Platform* platform, v8::Isolate* isolate,
     MessageLoopBehavior behavior = MessageLoopBehavior::kDoNotWait);
 
-V8_PLATFORM_EXPORT V8_DEPRECATED(
-    "This function has become obsolete and is essentially a nop",
-    void EnsureEventLoopInitialized(v8::Platform* platform,
-                                    v8::Isolate* isolate));
-
 /**
  * Runs pending idle tasks for at most |idle_time_in_seconds| seconds.
  *
diff --git a/test-app/runtime/src/main/cpp/include/libplatform/v8-tracing.h b/test-app/runtime/src/main/cpp/include/libplatform/v8-tracing.h
index 02f15955b..f9fe1fc8c 100644
--- a/test-app/runtime/src/main/cpp/include/libplatform/v8-tracing.h
+++ b/test-app/runtime/src/main/cpp/include/libplatform/v8-tracing.h
@@ -35,7 +35,7 @@ class V8_PLATFORM_EXPORT TraceObject {
             const char* as_string;
         };
 
-        TraceObject() {}
+        TraceObject() = default;
         ~TraceObject();
         void Initialize(
             char phase, const uint8_t* category_enabled_flag, const char* name,
@@ -138,8 +138,8 @@ class V8_PLATFORM_EXPORT TraceObject {
 
 class V8_PLATFORM_EXPORT TraceWriter {
     public:
-        TraceWriter() {}
-        virtual ~TraceWriter() {}
+        TraceWriter() = default;
+        virtual ~TraceWriter() = default;
         virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
         virtual void Flush() = 0;
 
@@ -187,8 +187,8 @@ class V8_PLATFORM_EXPORT TraceBufferChunk {
 
 class V8_PLATFORM_EXPORT TraceBuffer {
     public:
-        TraceBuffer() {}
-        virtual ~TraceBuffer() {}
+        TraceBuffer() = default;
+        virtual ~TraceBuffer() = default;
 
         virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0;
         virtual TraceObject* GetEventByHandle(uint64_t handle) = 0;
diff --git a/test-app/runtime/src/main/cpp/include/v8-inspector.h b/test-app/runtime/src/main/cpp/include/v8-inspector.h
index f28470b56..bdb0408f1 100644
--- a/test-app/runtime/src/main/cpp/include/v8-inspector.h
+++ b/test-app/runtime/src/main/cpp/include/v8-inspector.h
@@ -70,7 +70,7 @@ class V8_EXPORT StringView {
 
 class V8_EXPORT StringBuffer {
     public:
-        virtual ~StringBuffer() {}
+        virtual ~StringBuffer() = default;
         virtual const StringView& string() = 0;
         // This method copies contents.
         static std::unique_ptr<StringBuffer> create(const StringView&);
@@ -115,7 +115,7 @@ class V8_EXPORT V8StackTrace {
         virtual StringView topScriptId() const = 0;
         virtual StringView topFunctionName() const = 0;
 
-        virtual ~V8StackTrace() {}
+        virtual ~V8StackTrace() = default;
         virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
         buildInspectorObject() const = 0;
         virtual std::unique_ptr<StringBuffer> toString() const = 0;
@@ -126,13 +126,13 @@ class V8_EXPORT V8StackTrace {
 
 class V8_EXPORT V8InspectorSession {
     public:
-        virtual ~V8InspectorSession() {}
+        virtual ~V8InspectorSession() = default;
 
         // Cross-context inspectable values (DOM nodes in different worlds, etc.).
         class V8_EXPORT Inspectable {
             public:
                 virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
-                virtual ~Inspectable() {}
+                virtual ~Inspectable() = default;
         };
         virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
 
@@ -170,7 +170,7 @@ class V8_EXPORT V8InspectorSession {
 
 class V8_EXPORT V8InspectorClient {
     public:
-        virtual ~V8InspectorClient() {}
+        virtual ~V8InspectorClient() = default;
 
         virtual void runMessageLoopOnPause(int contextGroupId) {}
         virtual void quitMessageLoopOnPause() {}
@@ -229,6 +229,11 @@ class V8_EXPORT V8InspectorClient {
         }
 
         virtual void maxAsyncCallStackDepthChanged(int depth) {}
+
+        virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
+            const StringView& resourceName) {
+            return nullptr;
+        }
 };
 
 // These stack trace ids are intended to be passed between debuggers and be
@@ -248,12 +253,14 @@ struct V8_EXPORT V8StackTraceId {
 class V8_EXPORT V8Inspector {
     public:
         static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
-        virtual ~V8Inspector() {}
+        virtual ~V8Inspector() = default;
 
         // Contexts instrumentation.
         virtual void contextCreated(const V8ContextInfo&) = 0;
         virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
         virtual void resetContextGroup(int contextGroupId) = 0;
+        virtual v8::MaybeLocal<v8::Context> contextById(int groupId,
+                v8::Maybe<int> contextId) = 0;
 
         // Various instrumentation.
         virtual void idleStarted() = 0;
@@ -284,7 +291,7 @@ class V8_EXPORT V8Inspector {
         // Connection.
         class V8_EXPORT Channel {
             public:
-                virtual ~Channel() {}
+                virtual ~Channel() = default;
                 virtual void sendResponse(int callId,
                                           std::unique_ptr<StringBuffer> message) = 0;
                 virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
diff --git a/test-app/runtime/src/main/cpp/include/v8-internal.h b/test-app/runtime/src/main/cpp/include/v8-internal.h
new file mode 100644
index 000000000..c457b0cdc
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/include/v8-internal.h
@@ -0,0 +1,328 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_V8_INTERNAL_H_
+#define INCLUDE_V8_INTERNAL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <type_traits>
+
+#include "v8-version.h"  // NOLINT(build/include)
+#include "v8config.h"    // NOLINT(build/include)
+
+namespace v8 {
+
+class Context;
+class Data;
+class Isolate;
+
+namespace internal {
+
+class Object;
+
+/**
+ * Configuration of tagging scheme.
+ */
+const int kApiPointerSize = sizeof(void*);  // NOLINT
+const int kApiDoubleSize = sizeof(double);  // NOLINT
+const int kApiIntSize = sizeof(int);        // NOLINT
+const int kApiInt64Size = sizeof(int64_t);  // NOLINT
+
+// Tag information for HeapObject.
+const int kHeapObjectTag = 1;
+const int kWeakHeapObjectTag = 3;
+const int kHeapObjectTagSize = 2;
+const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
+
+// Tag information for Smi.
+const int kSmiTag = 0;
+const int kSmiTagSize = 1;
+const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
+
+template <size_t tagged_ptr_size>
+struct SmiTagging;
+
+template <int kSmiShiftSize>
+V8_INLINE internal::Object* IntToSmi(int value) {
+    int smi_shift_bits = kSmiTagSize + kSmiShiftSize;
+    intptr_t tagged_value =
+        (static_cast<intptr_t>(value) << smi_shift_bits) | kSmiTag;
+    return reinterpret_cast<internal::Object*>(tagged_value);
+}
+
+// Smi constants for systems where tagged pointer is a 32-bit value.
+template <>
+struct SmiTagging<4> {
+    enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
+    static int SmiShiftSize() {
+        return kSmiShiftSize;
+    }
+    static int SmiValueSize() {
+        return kSmiValueSize;
+    }
+    V8_INLINE static int SmiToInt(const internal::Object* value) {
+        int shift_bits = kSmiTagSize + kSmiShiftSize;
+        // Throw away top 32 bits and shift down (requires >> to be sign extending).
+        return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
+    }
+    V8_INLINE static internal::Object* IntToSmi(int value) {
+        return internal::IntToSmi<kSmiShiftSize>(value);
+    }
+    V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+        // To be representable as an tagged small integer, the two
+        // most-significant bits of 'value' must be either 00 or 11 due to
+        // sign-extension. To check this we add 01 to the two
+        // most-significant bits, and check if the most-significant bit is 0
+        //
+        // CAUTION: The original code below:
+        // bool result = ((value + 0x40000000) & 0x80000000) == 0;
+        // may lead to incorrect results according to the C language spec, and
+        // in fact doesn't work correctly with gcc4.1.1 in some cases: The
+        // compiler may produce undefined results in case of signed integer
+        // overflow. The computation must be done w/ unsigned ints.
+        return static_cast<uintptr_t>(value) + 0x40000000U < 0x80000000U;
+    }
+};
+
+// Smi constants for systems where tagged pointer is a 64-bit value.
+template <>
+struct SmiTagging<8> {
+    enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
+    static int SmiShiftSize() {
+        return kSmiShiftSize;
+    }
+    static int SmiValueSize() {
+        return kSmiValueSize;
+    }
+    V8_INLINE static int SmiToInt(const internal::Object* value) {
+        int shift_bits = kSmiTagSize + kSmiShiftSize;
+        // Shift down and throw away top 32 bits.
+        return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
+    }
+    V8_INLINE static internal::Object* IntToSmi(int value) {
+        return internal::IntToSmi<kSmiShiftSize>(value);
+    }
+    V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+        // To be representable as a long smi, the value must be a 32-bit integer.
+        return (value == static_cast<int32_t>(value));
+    }
+};
+
+#if V8_COMPRESS_POINTERS
+static_assert(
+    kApiPointerSize == kApiInt64Size,
+    "Pointer compression can be enabled only for 64-bit architectures");
+typedef SmiTagging<4> PlatformSmiTagging;
+#else
+typedef SmiTagging<kApiPointerSize> PlatformSmiTagging;
+#endif
+
+const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
+const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
+const int kSmiMinValue = (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
+const int kSmiMaxValue = -(kSmiMinValue + 1);
+constexpr bool SmiValuesAre31Bits() {
+    return kSmiValueSize == 31;
+}
+constexpr bool SmiValuesAre32Bits() {
+    return kSmiValueSize == 32;
+}
+
+/**
+ * This class exports constants and functionality from within v8 that
+ * is necessary to implement inline functions in the v8 api.  Don't
+ * depend on functions and constants defined here.
+ */
+class Internals {
+    public:
+        // These values match non-compiler-dependent values defined within
+        // the implementation of v8.
+        static const int kHeapObjectMapOffset = 0;
+        static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSize;
+        static const int kStringResourceOffset =
+            1 * kApiPointerSize + 2 * kApiIntSize;
+
+        static const int kOddballKindOffset = 4 * kApiPointerSize + kApiDoubleSize;
+        static const int kForeignAddressOffset = kApiPointerSize;
+        static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
+        static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
+        static const int kContextHeaderSize = 2 * kApiPointerSize;
+        static const int kContextEmbedderDataIndex = 5;
+        static const int kFullStringRepresentationMask = 0x0f;
+        static const int kStringEncodingMask = 0x8;
+        static const int kExternalTwoByteRepresentationTag = 0x02;
+        static const int kExternalOneByteRepresentationTag = 0x0a;
+
+        static const int kIsolateEmbedderDataOffset = 0 * kApiPointerSize;
+        static const int kExternalMemoryOffset = 4 * kApiPointerSize;
+        static const int kExternalMemoryLimitOffset =
+            kExternalMemoryOffset + kApiInt64Size;
+        static const int kExternalMemoryAtLastMarkCompactOffset =
+            kExternalMemoryLimitOffset + kApiInt64Size;
+        static const int kIsolateRootsOffset = kExternalMemoryLimitOffset +
+                                               kApiInt64Size + kApiInt64Size +
+                                               kApiPointerSize + kApiPointerSize;
+        static const int kUndefinedValueRootIndex = 4;
+        static const int kTheHoleValueRootIndex = 5;
+        static const int kNullValueRootIndex = 6;
+        static const int kTrueValueRootIndex = 7;
+        static const int kFalseValueRootIndex = 8;
+        static const int kEmptyStringRootIndex = 9;
+
+        static const int kNodeClassIdOffset = 1 * kApiPointerSize;
+        static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
+        static const int kNodeStateMask = 0x7;
+        static const int kNodeStateIsWeakValue = 2;
+        static const int kNodeStateIsPendingValue = 3;
+        static const int kNodeStateIsNearDeathValue = 4;
+        static const int kNodeIsIndependentShift = 3;
+        static const int kNodeIsActiveShift = 4;
+
+        static const int kFirstNonstringType = 0x80;
+        static const int kOddballType = 0x83;
+        static const int kForeignType = 0x87;
+        static const int kJSSpecialApiObjectType = 0x410;
+        static const int kJSApiObjectType = 0x420;
+        static const int kJSObjectType = 0x421;
+
+        static const int kUndefinedOddballKind = 5;
+        static const int kNullOddballKind = 3;
+
+        static const uint32_t kNumIsolateDataSlots = 4;
+
+        // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an
+        // incremental GC once the external memory reaches this limit.
+        static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024;
+
+        V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
+        V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
+#ifdef V8_ENABLE_CHECKS
+            CheckInitializedImpl(isolate);
+#endif
+        }
+
+        V8_INLINE static bool HasHeapObjectTag(const internal::Object* value) {
+            return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
+                    kHeapObjectTag);
+        }
+
+        V8_INLINE static int SmiValue(const internal::Object* value) {
+            return PlatformSmiTagging::SmiToInt(value);
+        }
+
+        V8_INLINE static internal::Object* IntToSmi(int value) {
+            return PlatformSmiTagging::IntToSmi(value);
+        }
+
+        V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+            return PlatformSmiTagging::IsValidSmi(value);
+        }
+
+        V8_INLINE static int GetInstanceType(const internal::Object* obj) {
+            typedef internal::Object O;
+            O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
+            return ReadField<uint16_t>(map, kMapInstanceTypeOffset);
+        }
+
+        V8_INLINE static int GetOddballKind(const internal::Object* obj) {
+            typedef internal::Object O;
+            return SmiValue(ReadField<O*>(obj, kOddballKindOffset));
+        }
+
+        V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
+            int representation = (instance_type & kFullStringRepresentationMask);
+            return representation == kExternalTwoByteRepresentationTag;
+        }
+
+        V8_INLINE static uint8_t GetNodeFlag(internal::Object** obj, int shift) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+            return *addr & static_cast<uint8_t>(1U << shift);
+        }
+
+        V8_INLINE static void UpdateNodeFlag(internal::Object** obj, bool value,
+                                             int shift) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+            uint8_t mask = static_cast<uint8_t>(1U << shift);
+            *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
+        }
+
+        V8_INLINE static uint8_t GetNodeState(internal::Object** obj) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+            return *addr & kNodeStateMask;
+        }
+
+        V8_INLINE static void UpdateNodeState(internal::Object** obj, uint8_t value) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+            *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
+        }
+
+        V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot,
+                                              void* data) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
+                            kIsolateEmbedderDataOffset + slot * kApiPointerSize;
+            *reinterpret_cast<void**>(addr) = data;
+        }
+
+        V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
+                                               uint32_t slot) {
+            const uint8_t* addr = reinterpret_cast<const uint8_t*>(isolate) +
+                                  kIsolateEmbedderDataOffset + slot * kApiPointerSize;
+            return *reinterpret_cast<void* const*>(addr);
+        }
+
+        V8_INLINE static internal::Object** GetRoot(v8::Isolate* isolate, int index) {
+            uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) + kIsolateRootsOffset;
+            return reinterpret_cast<internal::Object**>(addr + index * kApiPointerSize);
+        }
+
+        template <typename T>
+        V8_INLINE static T ReadField(const internal::Object* ptr, int offset) {
+            const uint8_t* addr =
+                reinterpret_cast<const uint8_t*>(ptr) + offset - kHeapObjectTag;
+            return *reinterpret_cast<const T*>(addr);
+        }
+
+        template <typename T>
+        V8_INLINE static T ReadEmbedderData(const v8::Context* context, int index) {
+            typedef internal::Object O;
+            typedef internal::Internals I;
+            O* ctx = *reinterpret_cast<O* const*>(context);
+            int embedder_data_offset =
+                I::kContextHeaderSize +
+                (internal::kApiPointerSize * I::kContextEmbedderDataIndex);
+            O* embedder_data = I::ReadField<O*>(ctx, embedder_data_offset);
+            int value_offset =
+                I::kFixedArrayHeaderSize + (internal::kApiPointerSize * index);
+            return I::ReadField<T>(embedder_data, value_offset);
+        }
+};
+
+// Only perform cast check for types derived from v8::Data since
+// other types do not implement the Cast method.
+template <bool PerformCheck>
+struct CastCheck {
+    template <class T>
+    static void Perform(T* data);
+};
+
+template <>
+template <class T>
+void CastCheck<true>::Perform(T* data) {
+    T::Cast(data);
+}
+
+template <>
+template <class T>
+void CastCheck<false>::Perform(T* data) {}
+
+template <class T>
+V8_INLINE void PerformCastCheck(T* data) {
+    CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_INTERNAL_H_
diff --git a/test-app/runtime/src/main/cpp/include/v8-platform.h b/test-app/runtime/src/main/cpp/include/v8-platform.h
index 590ae2eaa..4eebe9729 100644
--- a/test-app/runtime/src/main/cpp/include/v8-platform.h
+++ b/test-app/runtime/src/main/cpp/include/v8-platform.h
@@ -324,7 +324,9 @@ class Platform {
          * |isolate|. Tasks posted for the same isolate should be execute in order of
          * scheduling. The definition of "foreground" is opaque to V8.
          */
-        virtual void CallOnForegroundThread(Isolate* isolate, Task* task) = 0;
+        V8_DEPRECATE_SOON(
+            "Use a taskrunner acquired by GetForegroundTaskRunner instead.",
+            virtual void CallOnForegroundThread(Isolate* isolate, Task* task)) = 0;
 
         /**
          * Schedules a task to be invoked on a foreground thread wrt a specific
@@ -332,8 +334,10 @@ class Platform {
          * Tasks posted for the same isolate should be execute in order of
          * scheduling. The definition of "foreground" is opaque to V8.
          */
-        virtual void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
-                double delay_in_seconds) = 0;
+        V8_DEPRECATE_SOON(
+            "Use a taskrunner acquired by GetForegroundTaskRunner instead.",
+            virtual void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
+                    double delay_in_seconds)) = 0;
 
         /**
          * Schedules a task to be invoked on a foreground thread wrt a specific
@@ -343,7 +347,10 @@ class Platform {
          * starved for an arbitrarily long time if no idle time is available.
          * The definition of "foreground" is opaque to V8.
          */
-        virtual void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) {
+        V8_DEPRECATE_SOON(
+            "Use a taskrunner acquired by GetForegroundTaskRunner instead.",
+            virtual void CallIdleOnForegroundThread(Isolate* isolate,
+                    IdleTask* task)) {
             // This must be overriden if |IdleTasksEnabled()|.
             abort();
         }
diff --git a/test-app/runtime/src/main/cpp/include/v8-profiler.h b/test-app/runtime/src/main/cpp/include/v8-profiler.h
index ca7b0c21b..99211770a 100644
--- a/test-app/runtime/src/main/cpp/include/v8-profiler.h
+++ b/test-app/runtime/src/main/cpp/include/v8-profiler.h
@@ -47,24 +47,6 @@ template class V8_EXPORT std::vector<v8::CpuProfileDeoptInfo>;
 
 namespace v8 {
 
-/**
- * TracingCpuProfiler monitors tracing being enabled/disabled
- * and emits CpuProfile trace events once v8.cpu_profiler tracing category
- * is enabled. It has no overhead unless the category is enabled.
- */
-class V8_EXPORT TracingCpuProfiler {
-    public:
-        V8_DEPRECATED(
-            "The profiler is created automatically with the isolate.\n"
-            "No need to create it explicitly.",
-            static std::unique_ptr<TracingCpuProfiler> Create(Isolate*));
-
-        virtual ~TracingCpuProfiler() = default;
-
-    protected:
-        TracingCpuProfiler() = default;
-};
-
 // TickSample captures the information collected for each sample.
 struct TickSample {
     // Internal profiling (with --prof + tools/$OS-tick-processor) wants to
@@ -464,7 +446,7 @@ class V8_EXPORT OutputStream {  // NOLINT
             kContinue = 0,
             kAbort = 1
         };
-        virtual ~OutputStream() {}
+        virtual ~OutputStream() = default;
         /** Notify about the end of stream. */
         virtual void EndOfStream() = 0;
         /** Get preferred output chunk size. Called only once. */
@@ -560,7 +542,7 @@ class V8_EXPORT ActivityControl {  // NOLINT
             kContinue = 0,
             kAbort = 1
         };
-        virtual ~ActivityControl() {}
+        virtual ~ActivityControl() = default;
         /**
          * Notify about current progress. The activity can be stopped by
          * returning kAbort as the callback result.
@@ -646,7 +628,7 @@ class V8_EXPORT AllocationProfile {
          */
         virtual Node* GetRootNode() = 0;
 
-        virtual ~AllocationProfile() {}
+        virtual ~AllocationProfile() = default;
 
         static const int kNoLineNumberInfo = Message::kNoLineNumberInfo;
         static const int kNoColumnNumberInfo = Message::kNoColumnInfo;
@@ -822,15 +804,15 @@ class V8_EXPORT HeapProfiler {
                 virtual const char* GetName(Local<Object> object) = 0;
 
             protected:
-                virtual ~ObjectNameResolver() {}
+                virtual ~ObjectNameResolver() = default;
         };
 
         /**
          * Takes a heap snapshot and returns it.
          */
         const HeapSnapshot* TakeHeapSnapshot(
-            ActivityControl* control = NULL,
-            ObjectNameResolver* global_object_name_resolver = NULL);
+            ActivityControl* control = nullptr,
+            ObjectNameResolver* global_object_name_resolver = nullptr);
 
         /**
          * Starts tracking of heap objects population statistics. After calling
@@ -857,7 +839,7 @@ class V8_EXPORT HeapProfiler {
          * method.
          */
         SnapshotObjectId GetHeapStats(OutputStream* stream,
-                                      int64_t* timestamp_us = NULL);
+                                      int64_t* timestamp_us = nullptr);
 
         /**
          * Stops tracking of heap objects population statistics, cleans up all
@@ -926,7 +908,7 @@ class V8_EXPORT HeapProfiler {
             "Use AddBuildEmbedderGraphCallback to provide info about embedder nodes",
             void SetGetRetainerInfosCallback(GetRetainerInfosCallback callback));
 
-        V8_DEPRECATE_SOON(
+        V8_DEPRECATED(
             "Use AddBuildEmbedderGraphCallback to provide info about embedder nodes",
             void SetBuildEmbedderGraphCallback(
                 LegacyBuildEmbedderGraphCallback callback));
@@ -1020,8 +1002,8 @@ class V8_EXPORT RetainedObjectInfo {  // NOLINT
         }
 
     protected:
-        RetainedObjectInfo() {}
-        virtual ~RetainedObjectInfo() {}
+        RetainedObjectInfo() = default;
+        virtual ~RetainedObjectInfo() = default;
 
     private:
         RetainedObjectInfo(const RetainedObjectInfo&);
diff --git a/test-app/runtime/src/main/cpp/include/v8-util.h b/test-app/runtime/src/main/cpp/include/v8-util.h
index bc820e91f..014ef5131 100644
--- a/test-app/runtime/src/main/cpp/include/v8-util.h
+++ b/test-app/runtime/src/main/cpp/include/v8-util.h
@@ -112,11 +112,11 @@ class DefaultPersistentValueMapTraits : public StdMapTraits<K, V> {
 
         static WeakCallbackDataType* WeakCallbackParameter(
             MapType* map, const K& key, Local<V> value) {
-            return NULL;
+            return nullptr;
         }
         static MapType* MapFromWeakCallbackInfo(
             const WeakCallbackInfo<WeakCallbackDataType>& data) {
-            return NULL;
+            return nullptr;
         }
         static K KeyFromWeakCallbackInfo(
             const WeakCallbackInfo<WeakCallbackDataType>& data) {
@@ -332,7 +332,7 @@ class PersistentValueMapBase {
 
         static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
             V* v = persistent->val_;
-            persistent->val_ = 0;
+            persistent->val_ = nullptr;
             return reinterpret_cast<PersistentContainerValue>(v);
         }
 
@@ -663,7 +663,7 @@ class PersistentValueVector {
     private:
         static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
             V* v = persistent->val_;
-            persistent->val_ = 0;
+            persistent->val_ = nullptr;
             return reinterpret_cast<PersistentContainerValue>(v);
         }
 
diff --git a/test-app/runtime/src/main/cpp/include/v8-version.h b/test-app/runtime/src/main/cpp/include/v8-version.h
index 57fbc6296..0693f89ef 100644
--- a/test-app/runtime/src/main/cpp/include/v8-version.h
+++ b/test-app/runtime/src/main/cpp/include/v8-version.h
@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 6
-#define V8_MINOR_VERSION 9
-#define V8_BUILD_NUMBER 427
-#define V8_PATCH_LEVEL 23
+#define V8_MAJOR_VERSION 7
+#define V8_MINOR_VERSION 1
+#define V8_BUILD_NUMBER 302
+#define V8_PATCH_LEVEL 32
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/test-app/runtime/src/main/cpp/include/v8.h b/test-app/runtime/src/main/cpp/include/v8.h
index 5bf0606f9..0804bc565 100644
--- a/test-app/runtime/src/main/cpp/include/v8.h
+++ b/test-app/runtime/src/main/cpp/include/v8.h
@@ -22,42 +22,13 @@
 #include <utility>
 #include <vector>
 
-#include "v8-version.h"  // NOLINT(build/include)
-#include "v8config.h"    // NOLINT(build/include)
+#include "v8-internal.h"  // NOLINT(build/include)
+#include "v8-version.h"   // NOLINT(build/include)
+#include "v8config.h"     // NOLINT(build/include)
 
 // We reserve the V8_* prefix for macros defined in V8 public API and
 // assume there are no name conflicts with the embedder's code.
 
-#ifdef V8_OS_WIN
-
-// Setup for Windows DLL export/import. When building the V8 DLL the
-// BUILDING_V8_SHARED needs to be defined. When building a program which uses
-// the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
-// static library or building a program which uses the V8 static library neither
-// BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
-#ifdef BUILDING_V8_SHARED
-# define V8_EXPORT __declspec(dllexport)
-#elif USING_V8_SHARED
-# define V8_EXPORT __declspec(dllimport)
-#else
-# define V8_EXPORT
-#endif  // BUILDING_V8_SHARED
-
-#else  // V8_OS_WIN
-
-// Setup for Linux shared library export.
-#if V8_HAS_ATTRIBUTE_VISIBILITY
-# ifdef BUILDING_V8_SHARED
-#  define V8_EXPORT __attribute__ ((visibility("default")))
-# else
-#  define V8_EXPORT
-# endif
-#else
-# define V8_EXPORT
-#endif
-
-#endif  // V8_OS_WIN
-
 /**
  * The v8 JavaScript engine.
  */
@@ -153,120 +124,13 @@ template<typename T> class CustomArguments;
 class PropertyCallbackArguments;
 class FunctionCallbackArguments;
 class GlobalHandles;
+class ScopedExternalStringLock;
 
 namespace wasm {
-class CompilationResultResolver;
+class NativeModule;
 class StreamingDecoder;
 }  // namespace wasm
 
-/**
- * Configuration of tagging scheme.
- */
-const int kApiPointerSize = sizeof(void*);  // NOLINT
-const int kApiDoubleSize = sizeof(double);  // NOLINT
-const int kApiIntSize = sizeof(int);        // NOLINT
-const int kApiInt64Size = sizeof(int64_t);  // NOLINT
-
-// Tag information for HeapObject.
-const int kHeapObjectTag = 1;
-const int kWeakHeapObjectTag = 3;
-const int kHeapObjectTagSize = 2;
-const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
-
-// Tag information for Smi.
-const int kSmiTag = 0;
-const int kSmiTagSize = 1;
-const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
-
-template <size_t tagged_ptr_size>
-struct SmiTagging;
-
-template <int kSmiShiftSize>
-V8_INLINE internal::Object* IntToSmi(int value) {
-    int smi_shift_bits = kSmiTagSize + kSmiShiftSize;
-    intptr_t tagged_value =
-        (static_cast<intptr_t>(value) << smi_shift_bits) | kSmiTag;
-    return reinterpret_cast<internal::Object*>(tagged_value);
-}
-
-// Smi constants for systems where tagged pointer is a 32-bit value.
-template <>
-struct SmiTagging<4> {
-    enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
-    static int SmiShiftSize() {
-        return kSmiShiftSize;
-    }
-    static int SmiValueSize() {
-        return kSmiValueSize;
-    }
-    V8_INLINE static int SmiToInt(const internal::Object* value) {
-        int shift_bits = kSmiTagSize + kSmiShiftSize;
-        // Throw away top 32 bits and shift down (requires >> to be sign extending).
-        return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
-    }
-    V8_INLINE static internal::Object* IntToSmi(int value) {
-        return internal::IntToSmi<kSmiShiftSize>(value);
-    }
-    V8_INLINE static bool IsValidSmi(intptr_t value) {
-        // To be representable as an tagged small integer, the two
-        // most-significant bits of 'value' must be either 00 or 11 due to
-        // sign-extension. To check this we add 01 to the two
-        // most-significant bits, and check if the most-significant bit is 0
-        //
-        // CAUTION: The original code below:
-        // bool result = ((value + 0x40000000) & 0x80000000) == 0;
-        // may lead to incorrect results according to the C language spec, and
-        // in fact doesn't work correctly with gcc4.1.1 in some cases: The
-        // compiler may produce undefined results in case of signed integer
-        // overflow. The computation must be done w/ unsigned ints.
-        return static_cast<uintptr_t>(value) + 0x40000000U < 0x80000000U;
-    }
-};
-
-// Smi constants for systems where tagged pointer is a 64-bit value.
-template <>
-struct SmiTagging<8> {
-    enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
-    static int SmiShiftSize() {
-        return kSmiShiftSize;
-    }
-    static int SmiValueSize() {
-        return kSmiValueSize;
-    }
-    V8_INLINE static int SmiToInt(const internal::Object* value) {
-        int shift_bits = kSmiTagSize + kSmiShiftSize;
-        // Shift down and throw away top 32 bits.
-        return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
-    }
-    V8_INLINE static internal::Object* IntToSmi(int value) {
-        return internal::IntToSmi<kSmiShiftSize>(value);
-    }
-    V8_INLINE static bool IsValidSmi(intptr_t value) {
-        // To be representable as a long smi, the value must be a 32-bit integer.
-        return (value == static_cast<int32_t>(value));
-    }
-};
-
-#if V8_COMPRESS_POINTERS
-static_assert(
-    kApiPointerSize == kApiInt64Size,
-    "Pointer compression can be enabled only for 64-bit architectures");
-typedef SmiTagging<4> PlatformSmiTagging;
-#else
-typedef SmiTagging<kApiPointerSize> PlatformSmiTagging;
-#endif
-
-const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
-const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
-const int kSmiMinValue = (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
-const int kSmiMaxValue = -(kSmiMinValue + 1);
-constexpr bool SmiValuesAre31Bits() {
-    return kSmiValueSize == 31;
-}
-constexpr bool SmiValuesAre32Bits() {
-    return kSmiValueSize == 32;
-}
-
 }  // namespace internal
 
 namespace debug {
@@ -314,7 +178,7 @@ class ConsoleCallArguments;
 template <class T>
 class Local {
     public:
-        V8_INLINE Local() : val_(0) {}
+        V8_INLINE Local() : val_(nullptr) {}
         template <class S>
         V8_INLINE Local(Local<S> that)
             : val_(reinterpret_cast<T*>(*that)) {
@@ -330,14 +194,14 @@ class Local {
          * Returns true if the handle is empty.
          */
         V8_INLINE bool IsEmpty() const {
-            return val_ == 0;
+            return val_ == nullptr;
         }
 
         /**
          * Sets the handle to be empty. IsEmpty() will then return true.
          */
         V8_INLINE void Clear() {
-            val_ = 0;
+            val_ = nullptr;
         }
 
         V8_INLINE T* operator->() const {
@@ -358,10 +222,10 @@ class Local {
         V8_INLINE bool operator==(const Local<S>& that) const {
             internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
             internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-            if (a == 0) {
-                return b == 0;
+            if (a == nullptr) {
+                return b == nullptr;
             }
-            if (b == 0) {
+            if (b == nullptr) {
                 return false;
             }
             return *a == *b;
@@ -371,10 +235,10 @@ class Local {
             const PersistentBase<S>& that) const {
             internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
             internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-            if (a == 0) {
-                return b == 0;
+            if (a == nullptr) {
+                return b == nullptr;
             }
-            if (b == 0) {
+            if (b == nullptr) {
                 return false;
             }
             return *a == *b;
@@ -633,7 +497,7 @@ template <class T> class PersistentBase {
         V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
 
         V8_INLINE bool IsEmpty() const {
-            return val_ == NULL;
+            return val_ == nullptr;
         }
         V8_INLINE void Empty() {
             val_ = 0;
@@ -647,10 +511,10 @@ template <class T> class PersistentBase {
         V8_INLINE bool operator==(const PersistentBase<S>& that) const {
             internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
             internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-            if (a == NULL) {
-                return b == NULL;
+            if (a == nullptr) {
+                return b == nullptr;
             }
-            if (b == NULL) {
+            if (b == nullptr) {
                 return false;
             }
             return *a == *b;
@@ -660,10 +524,10 @@ template <class T> class PersistentBase {
         V8_INLINE bool operator==(const Local<S>& that) const {
             internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
             internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-            if (a == NULL) {
-                return b == NULL;
+            if (a == nullptr) {
+                return b == nullptr;
             }
-            if (b == NULL) {
+            if (b == nullptr) {
                 return false;
             }
             return *a == *b;
@@ -840,7 +704,7 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
         /**
          * A Persistent with no storage cell.
          */
-        V8_INLINE Persistent() : PersistentBase<T>(0) { }
+        V8_INLINE Persistent() : PersistentBase<T>(nullptr) {}
         /**
          * Construct a Persistent from a Local.
          * When the Local is non-empty, a new storage cell is created
@@ -867,7 +731,7 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
          * traits class is called, allowing the setting of flags based on the
          * copied Persistent.
          */
-        V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>(0) {
+        V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>(nullptr) {
             Copy(that);
         }
         template <class S, class M2>
@@ -1045,7 +909,7 @@ class V8_EXPORT HandleScope {
         void operator=(const HandleScope&) = delete;
 
     protected:
-        V8_INLINE HandleScope() {}
+        V8_INLINE HandleScope() = default;
 
         void Initialize(Isolate* isolate);
 
@@ -1085,7 +949,7 @@ class V8_EXPORT HandleScope {
 class V8_EXPORT EscapableHandleScope : public HandleScope {
     public:
         explicit EscapableHandleScope(Isolate* isolate);
-        V8_INLINE ~EscapableHandleScope() {}
+        V8_INLINE ~EscapableHandleScope() = default;
 
         /**
          * Pushes the value into the previous scope and returns a handle to it.
@@ -1191,10 +1055,6 @@ class V8_EXPORT PrimitiveArray {
         int Length() const;
         void Set(Isolate* isolate, int index, Local<Primitive> item);
         Local<Primitive> Get(Isolate* isolate, int index);
-
-        V8_DEPRECATE_SOON("Use Isolate version",
-                          void Set(int index, Local<Primitive> item));
-        V8_DEPRECATE_SOON("Use Isolate version", Local<Primitive> Get(int index));
 };
 
 /**
@@ -1436,23 +1296,15 @@ class V8_EXPORT Script {
         /**
          * A shorthand for ScriptCompiler::Compile().
          */
-        static V8_DEPRECATED("Use maybe version",
-                             Local<Script> Compile(Local<String> source,
-                                     ScriptOrigin* origin = nullptr));
         static V8_WARN_UNUSED_RESULT MaybeLocal<Script> Compile(
             Local<Context> context, Local<String> source,
             ScriptOrigin* origin = nullptr);
 
-        static Local<Script> V8_DEPRECATED("Use maybe version",
-                                           Compile(Local<String> source,
-                                                   Local<String> file_name));
-
         /**
          * Runs the script returning the resulting value. It will be run in the
          * context in which it was created (ScriptCompiler::CompileBound or
          * UnboundScript::BindToCurrentContext()).
          */
-        V8_DEPRECATED("Use maybe version", Local<Value> Run());
         V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context);
 
         /**
@@ -1481,7 +1333,7 @@ class V8_EXPORT ScriptCompiler {
             };
 
             CachedData()
-                : data(NULL),
+                : data(nullptr),
                   length(0),
                   rejected(false),
                   buffer_policy(BufferNotOwned) {}
@@ -1512,9 +1364,9 @@ class V8_EXPORT ScriptCompiler {
             public:
                 // Source takes ownership of CachedData.
                 V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin,
-                                 CachedData* cached_data = NULL);
+                                 CachedData* cached_data = nullptr);
                 V8_INLINE Source(Local<String> source_string,
-                                 CachedData* cached_data = NULL);
+                                 CachedData* cached_data = nullptr);
                 V8_INLINE ~Source();
 
                 // Ownership of the CachedData or its buffers is *not* transferred to the
@@ -1553,7 +1405,7 @@ class V8_EXPORT ScriptCompiler {
          */
         class V8_EXPORT ExternalSourceStream {
             public:
-                virtual ~ExternalSourceStream() {}
+                virtual ~ExternalSourceStream() = default;
 
                 /**
                  * V8 calls this to request the next chunk of data from the embedder. This
@@ -1596,12 +1448,11 @@ class V8_EXPORT ScriptCompiler {
                 virtual void ResetToBookmark();
         };
 
-
         /**
          * Source code which can be streamed into V8 in pieces. It will be parsed
-         * while streaming. It can be compiled after the streaming is complete.
-         * StreamedSource must be kept alive while the streaming task is ran (see
-         * ScriptStreamingTask below).
+         * while streaming and compiled after parsing has completed. StreamedSource
+         * must be kept alive while the streaming task is run (see ScriptStreamingTask
+         * below).
          */
         class V8_EXPORT StreamedSource {
             public:
@@ -1610,13 +1461,12 @@ class V8_EXPORT ScriptCompiler {
                 StreamedSource(ExternalSourceStream* source_stream, Encoding encoding);
                 ~StreamedSource();
 
-                // Ownership of the CachedData or its buffers is *not* transferred to the
-                // caller. The CachedData object is alive as long as the StreamedSource
-                // object is alive.
-                const CachedData* GetCachedData() const;
+                V8_DEPRECATED("No longer used", const CachedData* GetCachedData() const) {
+                    return nullptr;
+                }
 
                 internal::ScriptStreamingData* impl() const {
-                    return impl_;
+                    return impl_.get();
                 }
 
                 // Prevent copying.
@@ -1624,17 +1474,24 @@ class V8_EXPORT ScriptCompiler {
                 StreamedSource& operator=(const StreamedSource&) = delete;
 
             private:
-                internal::ScriptStreamingData* impl_;
+                std::unique_ptr<internal::ScriptStreamingData> impl_;
         };
 
         /**
          * A streaming task which the embedder must run on a background thread to
          * stream scripts into V8. Returned by ScriptCompiler::StartStreamingScript.
          */
-        class ScriptStreamingTask {
+        class V8_EXPORT ScriptStreamingTask final {
             public:
-                virtual ~ScriptStreamingTask() {}
-                virtual void Run() = 0;
+                void Run();
+
+            private:
+                friend class ScriptCompiler;
+
+                explicit ScriptStreamingTask(internal::ScriptStreamingData* data)
+                    : data_(data) {}
+
+                internal::ScriptStreamingData* data_;
         };
 
         enum CompileOptions {
@@ -1770,13 +1627,6 @@ class V8_EXPORT ScriptCompiler {
          * It is possible to specify multiple context extensions (obj in the above
          * example).
          */
-        static V8_DEPRECATED("Use maybe version",
-                             Local<Function> CompileFunctionInContext(
-                                 Isolate* isolate, Source* source,
-                                 Local<Context> context, size_t arguments_count,
-                                 Local<String> arguments[],
-                                 size_t context_extension_count,
-                                 Local<Object> context_extensions[]));
         static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext(
             Local<Context> context, Source* source, size_t arguments_count,
             Local<String> arguments[], size_t context_extension_count,
@@ -1799,10 +1649,6 @@ class V8_EXPORT ScriptCompiler {
         static CachedData* CreateCodeCache(
             Local<UnboundModuleScript> unbound_module_script);
 
-        V8_DEPRECATED("Source string is no longer required",
-                      static CachedData* CreateCodeCache(
-                          Local<UnboundScript> unbound_script, Local<String> source));
-
         /**
          * Creates and returns code cache for the specified function that was
          * previously produced by CompileFunctionInContext.
@@ -1811,10 +1657,6 @@ class V8_EXPORT ScriptCompiler {
          */
         static CachedData* CreateCodeCacheForFunction(Local<Function> function);
 
-        V8_DEPRECATED("Source string is no longer required",
-                      static CachedData* CreateCodeCacheForFunction(
-                          Local<Function> function, Local<String> source));
-
     private:
         static V8_WARN_UNUSED_RESULT MaybeLocal<UnboundScript> CompileUnboundInternal(
             Isolate* isolate, Source* source, CompileOptions options,
@@ -1829,7 +1671,11 @@ class V8_EXPORT Message {
     public:
         Local<String> Get() const;
 
-        V8_DEPRECATED("Use maybe version", Local<String> GetSourceLine() const);
+        /**
+         * Return the isolate to which the Message belongs.
+         */
+        Isolate* GetIsolate() const;
+
         V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSourceLine(
             Local<Context> context) const;
 
@@ -1855,7 +1701,6 @@ class V8_EXPORT Message {
         /**
          * Returns the number, 1-based, of the line where the error occurred.
          */
-        V8_DEPRECATED("Use maybe version", int GetLineNumber() const);
         V8_WARN_UNUSED_RESULT Maybe<int> GetLineNumber(Local<Context> context) const;
 
         /**
@@ -1935,8 +1780,6 @@ class V8_EXPORT StackTrace {
         /**
          * Returns a StackFrame at a particular index.
          */
-        V8_DEPRECATE_SOON("Use Isolate version",
-                          Local<StackFrame> GetFrame(uint32_t index) const);
         Local<StackFrame> GetFrame(Isolate* isolate, uint32_t index) const;
 
         /**
@@ -2053,6 +1896,11 @@ struct SampleInfo {
     // executing an external callback.
 };
 
+struct MemoryRange {
+    const void* start;
+    size_t length_in_bytes;
+};
+
 /**
  * A JSON Parser and Stringifier.
  */
@@ -2065,9 +1913,9 @@ class V8_EXPORT JSON {
          * \param json_string The string to parse.
          * \return The corresponding value if successfully parsed.
          */
-        static V8_DEPRECATE_SOON("Use the maybe version taking context",
-                                 MaybeLocal<Value> Parse(Isolate* isolate,
-                                         Local<String> json_string));
+        static V8_DEPRECATED("Use the maybe version taking context",
+                             MaybeLocal<Value> Parse(Isolate* isolate,
+                                     Local<String> json_string));
         static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
             Local<Context> context, Local<String> json_string);
 
@@ -2095,7 +1943,7 @@ class V8_EXPORT ValueSerializer {
     public:
         class V8_EXPORT Delegate {
             public:
-                virtual ~Delegate() {}
+                virtual ~Delegate() = default;
 
                 /**
                  * Handles the case where a DataCloneError would be thrown in the structured
@@ -2167,7 +2015,7 @@ class V8_EXPORT ValueSerializer {
          * Returns the stored data. This serializer should not be used once the buffer
          * is released. The contents are undefined if a previous write has failed.
          */
-        V8_DEPRECATE_SOON("Use Release()", std::vector<uint8_t> ReleaseBuffer());
+        V8_DEPRECATED("Use Release()", std::vector<uint8_t> ReleaseBuffer());
 
         /**
          * Returns the stored data (allocated using the delegate's
@@ -2188,10 +2036,10 @@ class V8_EXPORT ValueSerializer {
         /**
          * Similar to TransferArrayBuffer, but for SharedArrayBuffer.
          */
-        V8_DEPRECATE_SOON("Use Delegate::GetSharedArrayBufferId",
-                          void TransferSharedArrayBuffer(
-                              uint32_t transfer_id,
-                              Local<SharedArrayBuffer> shared_array_buffer));
+        V8_DEPRECATED("Use Delegate::GetSharedArrayBufferId",
+                      void TransferSharedArrayBuffer(
+                          uint32_t transfer_id,
+                          Local<SharedArrayBuffer> shared_array_buffer));
 
         /**
          * Indicate whether to treat ArrayBufferView objects as host objects,
@@ -2232,7 +2080,7 @@ class V8_EXPORT ValueDeserializer {
     public:
         class V8_EXPORT Delegate {
             public:
-                virtual ~Delegate() {}
+                virtual ~Delegate() = default;
 
                 /**
                  * The embedder overrides this method to read some kind of host object, if
@@ -2616,8 +2464,9 @@ class V8_EXPORT Value : public Data {
 
         V8_WARN_UNUSED_RESULT MaybeLocal<BigInt> ToBigInt(
             Local<Context> context) const;
-        V8_WARN_UNUSED_RESULT MaybeLocal<Boolean> ToBoolean(
-            Local<Context> context) const;
+        V8_DEPRECATE_SOON("ToBoolean can never throw. Use Local version.",
+                          V8_WARN_UNUSED_RESULT MaybeLocal<Boolean> ToBoolean(
+                              Local<Context> context) const);
         V8_WARN_UNUSED_RESULT MaybeLocal<Number> ToNumber(
             Local<Context> context) const;
         V8_WARN_UNUSED_RESULT MaybeLocal<String> ToString(
@@ -2632,8 +2481,7 @@ class V8_EXPORT Value : public Data {
             Local<Context> context) const;
         V8_WARN_UNUSED_RESULT MaybeLocal<Int32> ToInt32(Local<Context> context) const;
 
-        V8_DEPRECATE_SOON("Use maybe version",
-                          Local<Boolean> ToBoolean(Isolate* isolate) const);
+        Local<Boolean> ToBoolean(Isolate* isolate) const;
         V8_DEPRECATE_SOON("Use maybe version",
                           Local<Number> ToNumber(Isolate* isolate) const);
         V8_DEPRECATE_SOON("Use maybe version",
@@ -2645,13 +2493,6 @@ class V8_EXPORT Value : public Data {
         V8_DEPRECATE_SOON("Use maybe version",
                           Local<Int32> ToInt32(Isolate* isolate) const);
 
-        inline V8_DEPRECATE_SOON("Use maybe version",
-                                 Local<Boolean> ToBoolean() const);
-        inline V8_DEPRECATE_SOON("Use maybe version", Local<String> ToString() const);
-        inline V8_DEPRECATE_SOON("Use maybe version", Local<Object> ToObject() const);
-        inline V8_DEPRECATE_SOON("Use maybe version",
-                                 Local<Integer> ToInteger() const);
-
         /**
          * Attempts to convert a string to an array index.
          * Returns an empty handle if the conversion fails.
@@ -2659,7 +2500,11 @@ class V8_EXPORT Value : public Data {
         V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToArrayIndex(
             Local<Context> context) const;
 
-        V8_WARN_UNUSED_RESULT Maybe<bool> BooleanValue(Local<Context> context) const;
+        bool BooleanValue(Isolate* isolate) const;
+
+        V8_DEPRECATE_SOON("BooleanValue can never throw. Use Isolate version.",
+                          V8_WARN_UNUSED_RESULT Maybe<bool> BooleanValue(
+                              Local<Context> context) const);
         V8_WARN_UNUSED_RESULT Maybe<double> NumberValue(Local<Context> context) const;
         V8_WARN_UNUSED_RESULT Maybe<int64_t> IntegerValue(
             Local<Context> context) const;
@@ -2667,14 +2512,7 @@ class V8_EXPORT Value : public Data {
             Local<Context> context) const;
         V8_WARN_UNUSED_RESULT Maybe<int32_t> Int32Value(Local<Context> context) const;
 
-        V8_DEPRECATE_SOON("Use maybe version", bool BooleanValue() const);
-        V8_DEPRECATE_SOON("Use maybe version", double NumberValue() const);
-        V8_DEPRECATE_SOON("Use maybe version", int64_t IntegerValue() const);
-        V8_DEPRECATE_SOON("Use maybe version", uint32_t Uint32Value() const);
-        V8_DEPRECATE_SOON("Use maybe version", int32_t Int32Value() const);
-
         /** JS == */
-        V8_DEPRECATE_SOON("Use maybe version", bool Equals(Local<Value> that) const);
         V8_WARN_UNUSED_RESULT Maybe<bool> Equals(Local<Context> context,
                 Local<Value> that) const;
         bool StrictEquals(Local<Value> that) const;
@@ -2781,8 +2619,6 @@ class V8_EXPORT String : public Name {
          * Returns the number of bytes in the UTF-8 encoded
          * representation of this string.
          */
-        V8_DEPRECATE_SOON("Use Isolate version instead", int Utf8Length() const);
-
         int Utf8Length(Isolate* isolate) const;
 
         /**
@@ -2839,23 +2675,12 @@ class V8_EXPORT String : public Name {
         // 16-bit character codes.
         int Write(Isolate* isolate, uint16_t* buffer, int start = 0, int length = -1,
                   int options = NO_OPTIONS) const;
-        V8_DEPRECATE_SOON("Use Isolate* version",
-                          int Write(uint16_t* buffer, int start = 0, int length = -1,
-                                    int options = NO_OPTIONS) const);
         // One byte characters.
         int WriteOneByte(Isolate* isolate, uint8_t* buffer, int start = 0,
                          int length = -1, int options = NO_OPTIONS) const;
-        V8_DEPRECATE_SOON("Use Isolate* version",
-                          int WriteOneByte(uint8_t* buffer, int start = 0,
-                                           int length = -1, int options = NO_OPTIONS)
-                          const);
         // UTF-8 encoded characters.
         int WriteUtf8(Isolate* isolate, char* buffer, int length = -1,
-                      int* nchars_ref = NULL, int options = NO_OPTIONS) const;
-        V8_DEPRECATE_SOON("Use Isolate* version",
-                          int WriteUtf8(char* buffer, int length = -1,
-                                        int* nchars_ref = NULL,
-                                        int options = NO_OPTIONS) const);
+                      int* nchars_ref = nullptr, int options = NO_OPTIONS) const;
 
         /**
          * A zero length string.
@@ -2874,14 +2699,31 @@ class V8_EXPORT String : public Name {
 
         class V8_EXPORT ExternalStringResourceBase {  // NOLINT
             public:
-                virtual ~ExternalStringResourceBase() {}
+                virtual ~ExternalStringResourceBase() = default;
 
-                virtual bool IsCompressible() const {
+                V8_DEPRECATE_SOON("Use IsCacheable().",
+                                  virtual bool IsCompressible() const) {
                     return false;
                 }
 
+                /**
+                 * If a string is cacheable, the value returned by
+                 * ExternalStringResource::data() may be cached, otherwise it is not
+                 * expected to be stable beyond the current top-level task.
+                 */
+                virtual bool IsCacheable() const {
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+                    return !IsCompressible();
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+                }
+
             protected:
-                ExternalStringResourceBase() {}
+                ExternalStringResourceBase() = default;
 
                 /**
                  * Internally V8 will call this Dispose method when the external string
@@ -2893,6 +2735,24 @@ class V8_EXPORT String : public Name {
                     delete this;
                 }
 
+                /**
+                 * For a non-cacheable string, the value returned by
+                 * |ExternalStringResource::data()| has to be stable between |Lock()| and
+                 * |Unlock()|, that is the string must behave as is |IsCacheable()| returned
+                 * true.
+                 *
+                 * These two functions must be thread-safe, and can be called from anywhere.
+                 * They also must handle lock depth, in the sense that each can be called
+                 * several times, from different threads, and unlocking should only happen
+                 * when the balance of Lock() and Unlock() calls is 0.
+                 */
+                virtual void Lock() const {}
+
+                /**
+                 * Unlocks the string.
+                 */
+                virtual void Unlock() const {}
+
                 // Disallow copying and assigning.
                 ExternalStringResourceBase(const ExternalStringResourceBase&) = delete;
                 void operator=(const ExternalStringResourceBase&) = delete;
@@ -2900,6 +2760,7 @@ class V8_EXPORT String : public Name {
             private:
                 friend class internal::Heap;
                 friend class v8::String;
+                friend class internal::ScopedExternalStringLock;
         };
 
         /**
@@ -2915,7 +2776,7 @@ class V8_EXPORT String : public Name {
                  * Override the destructor to manage the life cycle of the underlying
                  * buffer.
                  */
-                virtual ~ExternalStringResource() {}
+                ~ExternalStringResource() override = default;
 
                 /**
                  * The string data from the underlying buffer.
@@ -2928,7 +2789,7 @@ class V8_EXPORT String : public Name {
                 virtual size_t length() const = 0;
 
             protected:
-                ExternalStringResource() {}
+                ExternalStringResource() = default;
         };
 
         /**
@@ -2948,13 +2809,13 @@ class V8_EXPORT String : public Name {
                  * Override the destructor to manage the life cycle of the underlying
                  * buffer.
                  */
-                virtual ~ExternalOneByteStringResource() {}
+                ~ExternalOneByteStringResource() override = default;
                 /** The string data from the underlying buffer.*/
                 virtual const char* data() const = 0;
                 /** The number of Latin-1 characters in the string.*/
                 virtual size_t length() const = 0;
             protected:
-                ExternalOneByteStringResource() {}
+                ExternalOneByteStringResource() = default;
         };
 
         /**
@@ -3023,9 +2884,6 @@ class V8_EXPORT String : public Name {
          */
         static Local<String> Concat(Isolate* isolate, Local<String> left,
                                     Local<String> right);
-        static V8_DEPRECATE_SOON("Use Isolate* version",
-                                 Local<String> Concat(Local<String> left,
-                                         Local<String> right));
 
         /**
          * Creates a new external string using the data defined in the given
@@ -3080,6 +2938,11 @@ class V8_EXPORT String : public Name {
          */
         bool CanMakeExternal();
 
+        /**
+         * Returns true if the strings values are equal. Same as JS ==/===.
+         */
+        bool StringEquals(Local<String> str);
+
         /**
          * Converts an object to a UTF-8-encoded character array.  Useful if
          * you want to print the object.  If conversion to a string fails
@@ -3089,8 +2952,6 @@ class V8_EXPORT String : public Name {
          */
         class V8_EXPORT Utf8Value {
             public:
-                V8_DEPRECATED("Use Isolate version",
-                              explicit Utf8Value(Local<v8::Value> obj));
                 Utf8Value(Isolate* isolate, Local<v8::Value> obj);
                 ~Utf8Value();
                 char* operator*() {
@@ -3120,7 +2981,6 @@ class V8_EXPORT String : public Name {
          */
         class V8_EXPORT Value {
             public:
-                V8_DEPRECATED("Use Isolate version", explicit Value(Local<v8::Value> obj));
                 Value(Isolate* isolate, Local<v8::Value> obj);
                 ~Value();
                 uint16_t* operator*() {
@@ -3146,6 +3006,12 @@ class V8_EXPORT String : public Name {
         void VerifyExternalStringResourceBase(ExternalStringResourceBase* v,
                                               Encoding encoding) const;
         void VerifyExternalStringResource(ExternalStringResource* val) const;
+        ExternalStringResource* GetExternalStringResourceSlow() const;
+        ExternalStringResourceBase* GetExternalStringResourceBaseSlow(
+            String::Encoding* encoding_out) const;
+        const ExternalOneByteStringResource* GetExternalOneByteStringResourceSlow()
+        const;
+
         static void CheckCast(v8::Value* obj);
 };
 
@@ -3182,6 +3048,7 @@ class V8_EXPORT Symbol : public Name {
         static Local<Symbol> ForApi(Isolate* isolate, Local<String> name);
 
         // Well-known symbols
+        static Local<Symbol> GetAsyncIterator(Isolate* isolate);
         static Local<Symbol> GetHasInstance(Isolate* isolate);
         static Local<Symbol> GetIsConcatSpreadable(Isolate* isolate);
         static Local<Symbol> GetIterator(Isolate* isolate);
@@ -3419,10 +3286,17 @@ enum PropertyFilter {
  * Options for marking whether callbacks may trigger JS-observable side effects.
  * Side-effect-free callbacks are whitelisted during debug evaluation with
  * throwOnSideEffect. It applies when calling a Function, FunctionTemplate,
- * or an Accessor's getter callback. For Interceptors, please see
+ * or an Accessor callback. For Interceptors, please see
  * PropertyHandlerFlags's kHasNoSideEffect.
+ * Callbacks that only cause side effects to the receiver are whitelisted if
+ * invoked on receiver objects that are created within the same debug-evaluate
+ * call, as these objects are temporary and the side effect does not escape.
  */
-enum class SideEffectType { kHasSideEffect, kHasNoSideEffect };
+enum class SideEffectType {
+    kHasSideEffect,
+    kHasNoSideEffect,
+    kHasSideEffectToReceiver
+};
 
 /**
  * Keys/Properties filter enums:
@@ -3560,10 +3434,12 @@ class V8_EXPORT Object : public Value {
          */
         V8_WARN_UNUSED_RESULT Maybe<bool> SetAccessor(
             Local<Context> context, Local<Name> name,
-            AccessorNameGetterCallback getter, AccessorNameSetterCallback setter = 0,
+            AccessorNameGetterCallback getter,
+            AccessorNameSetterCallback setter = nullptr,
             MaybeLocal<Value> data = MaybeLocal<Value>(),
             AccessControl settings = DEFAULT, PropertyAttribute attribute = None,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         void SetAccessorProperty(Local<Name> name, Local<Function> getter,
                                  Local<Function> setter = Local<Function>(),
@@ -3579,7 +3455,8 @@ class V8_EXPORT Object : public Value {
             AccessorNameGetterCallback getter,
             AccessorNameSetterCallback setter = nullptr,
             Local<Value> data = Local<Value>(), PropertyAttribute attributes = None,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         /**
          * Attempts to create a property with the given name which behaves like a data
@@ -3593,7 +3470,8 @@ class V8_EXPORT Object : public Value {
             Local<Context> context, Local<Name> name,
             AccessorNameGetterCallback getter, Local<Value> data = Local<Value>(),
             PropertyAttribute attributes = None,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         /**
          * Functionality for private properties.
@@ -4304,8 +4182,6 @@ class V8_EXPORT Promise : public Object {
                 /**
                  * Create a new resolver, along with an associated promise in pending state.
                  */
-                static V8_DEPRECATED("Use maybe version",
-                                     Local<Resolver> New(Isolate* isolate));
                 static V8_WARN_UNUSED_RESULT MaybeLocal<Resolver> New(
                     Local<Context> context);
 
@@ -4318,11 +4194,9 @@ class V8_EXPORT Promise : public Object {
                  * Resolve/reject the associated promise with a given value.
                  * Ignored if the promise is no longer pending.
                  */
-                V8_DEPRECATED("Use maybe version", void Resolve(Local<Value> value));
                 V8_WARN_UNUSED_RESULT Maybe<bool> Resolve(Local<Context> context,
                         Local<Value> value);
 
-                V8_DEPRECATED("Use maybe version", void Reject(Local<Value> value));
                 V8_WARN_UNUSED_RESULT Maybe<bool> Reject(Local<Context> context,
                         Local<Value> value);
 
@@ -4477,13 +4351,6 @@ class V8_EXPORT WasmCompiledModule : public Object {
     public:
         typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> SerializedModule;
 
-// The COMMA macro allows us to use ',' inside of the V8_DEPRECATE_SOON macro.
-#define COMMA ,
-        V8_DEPRECATE_SOON(
-            "Use BufferReference.",
-            typedef std::pair<const uint8_t* COMMA size_t> CallerOwnedBuffer);
-#undef COMMA
-
         /**
          * A unowned reference to a byte buffer.
          */
@@ -4492,12 +4359,6 @@ class V8_EXPORT WasmCompiledModule : public Object {
             size_t size;
             BufferReference(const uint8_t* start, size_t size)
                 : start(start), size(size) {}
-            // Temporarily allow conversion to and from CallerOwnedBuffer.
-            V8_DEPRECATE_SOON(
-                "Use BufferReference directly.",
-                inline BufferReference(CallerOwnedBuffer));  // NOLINT(runtime/explicit)
-            V8_DEPRECATE_SOON("Use BufferReference directly.",
-                              inline operator CallerOwnedBuffer());
         };
 
         /**
@@ -4513,13 +4374,17 @@ class V8_EXPORT WasmCompiledModule : public Object {
                 TransferrableModule& operator=(const TransferrableModule& src) = delete;
 
             private:
+                typedef std::shared_ptr<internal::wasm::NativeModule> SharedModule;
                 typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> OwnedBuffer;
                 friend class WasmCompiledModule;
-                TransferrableModule(OwnedBuffer code, OwnedBuffer bytes)
-                    : compiled_code(std::move(code)), wire_bytes(std::move(bytes)) {}
-
-                OwnedBuffer compiled_code = {nullptr, 0};
-                OwnedBuffer wire_bytes = {nullptr, 0};
+                explicit TransferrableModule(SharedModule shared_module)
+                    : shared_module_(std::move(shared_module)) {}
+                TransferrableModule(OwnedBuffer serialized, OwnedBuffer bytes)
+                    : serialized_(std::move(serialized)), wire_bytes_(std::move(bytes)) {}
+
+                SharedModule shared_module_;
+                OwnedBuffer serialized_ = {nullptr, 0};
+                OwnedBuffer wire_bytes_ = {nullptr, 0};
         };
 
         /**
@@ -4540,8 +4405,6 @@ class V8_EXPORT WasmCompiledModule : public Object {
          * Get the wasm-encoded bytes that were used to compile this module.
          */
         BufferReference GetWasmWireBytesRef();
-        V8_DEPRECATE_SOON("Use GetWasmWireBytesRef version.",
-                          Local<String> GetWasmWireBytes());
 
         /**
          * Serialize the compiled module. The serialized data does not include the
@@ -4574,15 +4437,6 @@ class V8_EXPORT WasmCompiledModule : public Object {
         static void CheckCast(Value* obj);
 };
 
-// TODO(clemensh): Remove after M69 branch.
-WasmCompiledModule::BufferReference::BufferReference(
-    WasmCompiledModule::CallerOwnedBuffer buf)
-    : BufferReference(buf.first, buf.second) {}
-WasmCompiledModule::BufferReference::
-operator WasmCompiledModule::CallerOwnedBuffer() {
-    return {start, size};
-}
-
 /**
  * The V8 interface for WebAssembly streaming compilation. When streaming
  * compilation is initiated, V8 passes a {WasmStreaming} object to the embedder
@@ -4647,7 +4501,7 @@ class V8_EXPORT WasmModuleObjectBuilderStreaming final {
         void Abort(MaybeLocal<Value> exception);
         Local<Promise> GetPromise();
 
-        ~WasmModuleObjectBuilderStreaming();
+        ~WasmModuleObjectBuilderStreaming() = default;
 
     private:
         WasmModuleObjectBuilderStreaming(const WasmModuleObjectBuilderStreaming&) =
@@ -4706,7 +4560,7 @@ class V8_EXPORT ArrayBuffer : public Object {
          */
         class V8_EXPORT Allocator { // NOLINT
             public:
-                virtual ~Allocator() {}
+                virtual ~Allocator() = default;
 
                 /**
                  * Allocate |length| bytes. Return NULL if allocation is not successful.
@@ -4747,17 +4601,22 @@ class V8_EXPORT ArrayBuffer : public Object {
          * returns an instance of this class, populated, with a pointer to data
          * and byte length.
          *
-         * The Data pointer of ArrayBuffer::Contents is always allocated with
-         * Allocator::Allocate that is set via Isolate::CreateParams.
+         * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+         * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+         * was allocated with ArraryBuffer::Allocator::Allocate.
          */
         class V8_EXPORT Contents { // NOLINT
             public:
+                using DeleterCallback = void (*)(void* buffer, size_t length, void* info);
+
                 Contents()
                     : data_(nullptr),
                       byte_length_(0),
                       allocation_base_(nullptr),
                       allocation_length_(0),
-                      allocation_mode_(Allocator::AllocationMode::kNormal) {}
+                      allocation_mode_(Allocator::AllocationMode::kNormal),
+                      deleter_(nullptr),
+                      deleter_data_(nullptr) {}
 
                 void* AllocationBase() const {
                     return allocation_base_;
@@ -4775,13 +4634,26 @@ class V8_EXPORT ArrayBuffer : public Object {
                 size_t ByteLength() const {
                     return byte_length_;
                 }
+                DeleterCallback Deleter() const {
+                    return deleter_;
+                }
+                void* DeleterData() const {
+                    return deleter_data_;
+                }
 
             private:
+                Contents(void* data, size_t byte_length, void* allocation_base,
+                         size_t allocation_length,
+                         Allocator::AllocationMode allocation_mode, DeleterCallback deleter,
+                         void* deleter_data);
+
                 void* data_;
                 size_t byte_length_;
                 void* allocation_base_;
                 size_t allocation_length_;
                 Allocator::AllocationMode allocation_mode_;
+                DeleterCallback deleter_;
+                void* deleter_data_;
 
                 friend class ArrayBuffer;
         };
@@ -4838,8 +4710,9 @@ class V8_EXPORT ArrayBuffer : public Object {
          * had been externalized, it does no longer own the memory block. The caller
          * should take steps to free memory when it is no longer needed.
          *
-         * The memory block is guaranteed to be allocated with |Allocator::Allocate|
-         * that has been set via Isolate::CreateParams.
+         * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+         * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+         * was allocated with ArraryBuffer::Allocator::Allocate.
          */
         Contents Externalize();
 
@@ -4850,8 +4723,6 @@ class V8_EXPORT ArrayBuffer : public Object {
          *
          * The embedder should make sure to hold a strong reference to the
          * ArrayBuffer while accessing this pointer.
-         *
-         * The memory block is guaranteed to be allocated with |Allocator::Allocate|.
          */
         Contents GetContents();
 
@@ -5158,20 +5029,25 @@ class V8_EXPORT SharedArrayBuffer : public Object {
          * |SharedArrayBuffer| returns an instance of this class, populated, with a
          * pointer to data and byte length.
          *
-         * The Data pointer of SharedArrayBuffer::Contents is always allocated with
-         * |ArrayBuffer::Allocator::Allocate| by the allocator specified in
-         * v8::Isolate::CreateParams::array_buffer_allocator.
+         * The Data pointer of ArrayBuffer::Contents must be freed using the provided
+         * deleter, which will call ArrayBuffer::Allocator::Free if the buffer
+         * was allocated with ArraryBuffer::Allocator::Allocate.
          *
          * This API is experimental and may change significantly.
          */
         class V8_EXPORT Contents {  // NOLINT
             public:
+                using Allocator = v8::ArrayBuffer::Allocator;
+                using DeleterCallback = void (*)(void* buffer, size_t length, void* info);
+
                 Contents()
                     : data_(nullptr),
                       byte_length_(0),
                       allocation_base_(nullptr),
                       allocation_length_(0),
-                      allocation_mode_(ArrayBuffer::Allocator::AllocationMode::kNormal) {}
+                      allocation_mode_(Allocator::AllocationMode::kNormal),
+                      deleter_(nullptr),
+                      deleter_data_(nullptr) {}
 
                 void* AllocationBase() const {
                     return allocation_base_;
@@ -5179,7 +5055,7 @@ class V8_EXPORT SharedArrayBuffer : public Object {
                 size_t AllocationLength() const {
                     return allocation_length_;
                 }
-                ArrayBuffer::Allocator::AllocationMode AllocationMode() const {
+                Allocator::AllocationMode AllocationMode() const {
                     return allocation_mode_;
                 }
 
@@ -5189,18 +5065,30 @@ class V8_EXPORT SharedArrayBuffer : public Object {
                 size_t ByteLength() const {
                     return byte_length_;
                 }
+                DeleterCallback Deleter() const {
+                    return deleter_;
+                }
+                void* DeleterData() const {
+                    return deleter_data_;
+                }
 
             private:
+                Contents(void* data, size_t byte_length, void* allocation_base,
+                         size_t allocation_length,
+                         Allocator::AllocationMode allocation_mode, DeleterCallback deleter,
+                         void* deleter_data);
+
                 void* data_;
                 size_t byte_length_;
                 void* allocation_base_;
                 size_t allocation_length_;
-                ArrayBuffer::Allocator::AllocationMode allocation_mode_;
+                Allocator::AllocationMode allocation_mode_;
+                DeleterCallback deleter_;
+                void* deleter_data_;
 
                 friend class SharedArrayBuffer;
         };
 
-
         /**
          * Data length in bytes.
          */
@@ -5273,8 +5161,8 @@ class V8_EXPORT SharedArrayBuffer : public Object {
  */
 class V8_EXPORT Date : public Object {
     public:
-        static V8_DEPRECATE_SOON("Use maybe version.",
-                                 Local<Value> New(Isolate* isolate, double time));
+        static V8_DEPRECATED("Use maybe version.",
+                             Local<Value> New(Isolate* isolate, double time));
         static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context,
                 double time);
 
@@ -5357,8 +5245,6 @@ class V8_EXPORT BooleanObject : public Object {
 class V8_EXPORT StringObject : public Object {
     public:
         static Local<Value> New(Isolate* isolate, Local<String> value);
-        static V8_DEPRECATE_SOON("Use Isolate* version",
-                                 Local<Value> New(Local<String> value));
 
         Local<String> ValueOf() const;
 
@@ -5414,8 +5300,6 @@ class V8_EXPORT RegExp : public Object {
          *               static_cast<RegExp::Flags>(kGlobal | kMultiline))
          * is equivalent to evaluating "/foo/gm".
          */
-        static V8_DEPRECATED("Use maybe version",
-                             Local<RegExp> New(Local<String> pattern, Flags flags));
         static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> New(Local<Context> context,
                 Local<String> pattern,
                 Flags flags);
@@ -5521,20 +5405,22 @@ class V8_EXPORT Template : public Data {
          */
         void SetNativeDataProperty(
             Local<String> name, AccessorGetterCallback getter,
-            AccessorSetterCallback setter = 0,
+            AccessorSetterCallback setter = nullptr,
             // TODO(dcarney): gcc can't handle Local below
             Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
             Local<AccessorSignature> signature = Local<AccessorSignature>(),
             AccessControl settings = DEFAULT,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
         void SetNativeDataProperty(
             Local<Name> name, AccessorNameGetterCallback getter,
-            AccessorNameSetterCallback setter = 0,
+            AccessorNameSetterCallback setter = nullptr,
             // TODO(dcarney): gcc can't handle Local below
             Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
             Local<AccessorSignature> signature = Local<AccessorSignature>(),
             AccessControl settings = DEFAULT,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         /**
          * Like SetNativeDataProperty, but V8 will replace the native data property
@@ -5543,7 +5429,8 @@ class V8_EXPORT Template : public Data {
         void SetLazyDataProperty(
             Local<Name> name, AccessorNameGetterCallback getter,
             Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         /**
          * During template instantiation, sets the value with the intrinsic property
@@ -5559,57 +5446,8 @@ class V8_EXPORT Template : public Data {
         friend class FunctionTemplate;
 };
 
-
-/**
- * NamedProperty[Getter|Setter] are used as interceptors on object.
- * See ObjectTemplate::SetNamedPropertyHandler.
- */
-typedef void (*NamedPropertyGetterCallback)(
-    Local<String> property,
-    const PropertyCallbackInfo<Value>& info);
-
-
-/**
- * Returns the value if the setter intercepts the request.
- * Otherwise, returns an empty handle.
- */
-typedef void (*NamedPropertySetterCallback)(
-    Local<String> property,
-    Local<Value> value,
-    const PropertyCallbackInfo<Value>& info);
-
-
-/**
- * Returns a non-empty handle if the interceptor intercepts the request.
- * The result is an integer encoding property attributes (like v8::None,
- * v8::DontEnum, etc.)
- */
-typedef void (*NamedPropertyQueryCallback)(
-    Local<String> property,
-    const PropertyCallbackInfo<Integer>& info);
-
-
-/**
- * Returns a non-empty handle if the deleter intercepts the request.
- * The return value is true if the property could be deleted and false
- * otherwise.
- */
-typedef void (*NamedPropertyDeleterCallback)(
-    Local<String> property,
-    const PropertyCallbackInfo<Boolean>& info);
-
-/**
- * Returns an array containing the names of the properties the named
- * property getter intercepts.
- *
- * Note: The values in the array must be of type v8::Name.
- */
-typedef void (*NamedPropertyEnumeratorCallback)(
-    const PropertyCallbackInfo<Array>& info);
-
-
-// TODO(dcarney): Deprecate and remove previous typedefs, and replace
-// GenericNamedPropertyFooCallback with just NamedPropertyFooCallback.
+// TODO(dcarney): Replace GenericNamedPropertyFooCallback with just
+// NamedPropertyFooCallback.
 
 /**
  * Interceptor for get requests on an object.
@@ -5953,7 +5791,7 @@ class V8_EXPORT FunctionTemplate : public Template {
     public:
         /** Creates a function template.*/
         static Local<FunctionTemplate> New(
-            Isolate* isolate, FunctionCallback callback = 0,
+            Isolate* isolate, FunctionCallback callback = nullptr,
             Local<Value> data = Local<Value>(),
             Local<Signature> signature = Local<Signature>(), int length = 0,
             ConstructorBehavior behavior = ConstructorBehavior::kAllow,
@@ -6112,13 +5950,33 @@ enum class PropertyHandlerFlags {
 };
 
 struct NamedPropertyHandlerConfiguration {
+    NamedPropertyHandlerConfiguration(
+        GenericNamedPropertyGetterCallback getter,
+        GenericNamedPropertySetterCallback setter,
+        GenericNamedPropertyQueryCallback query,
+        GenericNamedPropertyDeleterCallback deleter,
+        GenericNamedPropertyEnumeratorCallback enumerator,
+        GenericNamedPropertyDefinerCallback definer,
+        GenericNamedPropertyDescriptorCallback descriptor,
+        Local<Value> data = Local<Value>(),
+        PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
+        : getter(getter),
+          setter(setter),
+          query(query),
+          deleter(deleter),
+          enumerator(enumerator),
+          definer(definer),
+          descriptor(descriptor),
+          data(data),
+          flags(flags) {}
+
     NamedPropertyHandlerConfiguration(
         /** Note: getter is required */
-        GenericNamedPropertyGetterCallback getter = 0,
-        GenericNamedPropertySetterCallback setter = 0,
-        GenericNamedPropertyQueryCallback query = 0,
-        GenericNamedPropertyDeleterCallback deleter = 0,
-        GenericNamedPropertyEnumeratorCallback enumerator = 0,
+        GenericNamedPropertyGetterCallback getter = nullptr,
+        GenericNamedPropertySetterCallback setter = nullptr,
+        GenericNamedPropertyQueryCallback query = nullptr,
+        GenericNamedPropertyDeleterCallback deleter = nullptr,
+        GenericNamedPropertyEnumeratorCallback enumerator = nullptr,
         Local<Value> data = Local<Value>(),
         PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
         : getter(getter),
@@ -6126,8 +5984,8 @@ struct NamedPropertyHandlerConfiguration {
           query(query),
           deleter(deleter),
           enumerator(enumerator),
-          definer(0),
-          descriptor(0),
+          definer(nullptr),
+          descriptor(nullptr),
           data(data),
           flags(flags) {}
 
@@ -6142,7 +6000,7 @@ struct NamedPropertyHandlerConfiguration {
         PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
         : getter(getter),
           setter(setter),
-          query(0),
+          query(nullptr),
           deleter(deleter),
           enumerator(enumerator),
           definer(definer),
@@ -6163,13 +6021,32 @@ struct NamedPropertyHandlerConfiguration {
 
 
 struct IndexedPropertyHandlerConfiguration {
+    IndexedPropertyHandlerConfiguration(
+        IndexedPropertyGetterCallback getter,
+        IndexedPropertySetterCallback setter, IndexedPropertyQueryCallback query,
+        IndexedPropertyDeleterCallback deleter,
+        IndexedPropertyEnumeratorCallback enumerator,
+        IndexedPropertyDefinerCallback definer,
+        IndexedPropertyDescriptorCallback descriptor,
+        Local<Value> data = Local<Value>(),
+        PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
+        : getter(getter),
+          setter(setter),
+          query(query),
+          deleter(deleter),
+          enumerator(enumerator),
+          definer(definer),
+          descriptor(descriptor),
+          data(data),
+          flags(flags) {}
+
     IndexedPropertyHandlerConfiguration(
         /** Note: getter is required */
-        IndexedPropertyGetterCallback getter = 0,
-        IndexedPropertySetterCallback setter = 0,
-        IndexedPropertyQueryCallback query = 0,
-        IndexedPropertyDeleterCallback deleter = 0,
-        IndexedPropertyEnumeratorCallback enumerator = 0,
+        IndexedPropertyGetterCallback getter = nullptr,
+        IndexedPropertySetterCallback setter = nullptr,
+        IndexedPropertyQueryCallback query = nullptr,
+        IndexedPropertyDeleterCallback deleter = nullptr,
+        IndexedPropertyEnumeratorCallback enumerator = nullptr,
         Local<Value> data = Local<Value>(),
         PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
         : getter(getter),
@@ -6177,8 +6054,8 @@ struct IndexedPropertyHandlerConfiguration {
           query(query),
           deleter(deleter),
           enumerator(enumerator),
-          definer(0),
-          descriptor(0),
+          definer(nullptr),
+          descriptor(nullptr),
           data(data),
           flags(flags) {}
 
@@ -6193,7 +6070,7 @@ struct IndexedPropertyHandlerConfiguration {
         PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
         : getter(getter),
           setter(setter),
-          query(0),
+          query(nullptr),
           deleter(deleter),
           enumerator(enumerator),
           definer(definer),
@@ -6265,49 +6142,20 @@ class V8_EXPORT ObjectTemplate : public Template {
          */
         void SetAccessor(
             Local<String> name, AccessorGetterCallback getter,
-            AccessorSetterCallback setter = 0, Local<Value> data = Local<Value>(),
-            AccessControl settings = DEFAULT, PropertyAttribute attribute = None,
+            AccessorSetterCallback setter = nullptr,
+            Local<Value> data = Local<Value>(), AccessControl settings = DEFAULT,
+            PropertyAttribute attribute = None,
             Local<AccessorSignature> signature = Local<AccessorSignature>(),
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
         void SetAccessor(
             Local<Name> name, AccessorNameGetterCallback getter,
-            AccessorNameSetterCallback setter = 0, Local<Value> data = Local<Value>(),
-            AccessControl settings = DEFAULT, PropertyAttribute attribute = None,
+            AccessorNameSetterCallback setter = nullptr,
+            Local<Value> data = Local<Value>(), AccessControl settings = DEFAULT,
+            PropertyAttribute attribute = None,
             Local<AccessorSignature> signature = Local<AccessorSignature>(),
-            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect);
-
-        /**
-         * Sets a named property handler on the object template.
-         *
-         * Whenever a property whose name is a string is accessed on objects created
-         * from this object template, the provided callback is invoked instead of
-         * accessing the property directly on the JavaScript object.
-         *
-         * SetNamedPropertyHandler() is different from SetHandler(), in
-         * that the latter can intercept symbol-named properties as well as
-         * string-named properties when called with a
-         * NamedPropertyHandlerConfiguration. New code should use SetHandler().
-         *
-         * \param getter The callback to invoke when getting a property.
-         * \param setter The callback to invoke when setting a property.
-         * \param query The callback to invoke to check if a property is present,
-         *   and if present, get its attributes.
-         * \param deleter The callback to invoke when deleting a property.
-         * \param enumerator The callback to invoke to enumerate all the named
-         *   properties of an object.
-         * \param data A piece of data that will be passed to the callbacks
-         *   whenever they are invoked.
-         */
-        V8_DEPRECATED(
-            "Use SetHandler(const NamedPropertyHandlerConfiguration) "
-            "with the kOnlyInterceptStrings flag set.",
-            void SetNamedPropertyHandler(
-                NamedPropertyGetterCallback getter,
-                NamedPropertySetterCallback setter = 0,
-                NamedPropertyQueryCallback query = 0,
-                NamedPropertyDeleterCallback deleter = 0,
-                NamedPropertyEnumeratorCallback enumerator = 0,
-                Local<Value> data = Local<Value>()));
+            SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+            SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
         /**
          * Sets a named property handler on the object template.
@@ -6341,10 +6189,10 @@ class V8_EXPORT ObjectTemplate : public Template {
         // TODO(dcarney): deprecate
         void SetIndexedPropertyHandler(
             IndexedPropertyGetterCallback getter,
-            IndexedPropertySetterCallback setter = 0,
-            IndexedPropertyQueryCallback query = 0,
-            IndexedPropertyDeleterCallback deleter = 0,
-            IndexedPropertyEnumeratorCallback enumerator = 0,
+            IndexedPropertySetterCallback setter = nullptr,
+            IndexedPropertyQueryCallback query = nullptr,
+            IndexedPropertyDeleterCallback deleter = nullptr,
+            IndexedPropertyEnumeratorCallback enumerator = nullptr,
             Local<Value> data = Local<Value>()) {
             SetHandler(IndexedPropertyHandlerConfiguration(getter, setter, query,
                        deleter, enumerator, data));
@@ -6480,24 +6328,20 @@ class V8_EXPORT AccessorSignature : public Data {
 
 
 // --- Extensions ---
-V8_DEPRECATE_SOON("Implementation detail",
-                  class ExternalOneByteStringResourceImpl);
-class V8_EXPORT ExternalOneByteStringResourceImpl
-    : public String::ExternalOneByteStringResource {
-    public:
-        ExternalOneByteStringResourceImpl() : data_(0), length_(0) {}
-        ExternalOneByteStringResourceImpl(const char* data, size_t length)
-            : data_(data), length_(length) {}
-        const char* data() const {
-            return data_;
-        }
-        size_t length() const {
-            return length_;
-        }
+V8_DEPRECATE_SOON("Implementation detail", class)
+V8_EXPORT ExternalOneByteStringResourceImpl
+:
+public String::ExternalOneByteStringResource {
+public:
+    ExternalOneByteStringResourceImpl() : data_(nullptr), length_(0) {}
+    ExternalOneByteStringResourceImpl(const char* data, size_t length)
+        : data_(data), length_(length) {}
+    const char* data() const override { return data_; }
+    size_t length() const override { return length_; }
 
-    private:
-        const char* data_;
-        size_t length_;
+private:
+    const char* data_;
+    size_t length_;
 };
 
 /**
@@ -6507,11 +6351,8 @@ class V8_EXPORT Extension {  // NOLINT
     public:
         // Note that the strings passed into this constructor must live as long
         // as the Extension itself.
-        Extension(const char* name,
-                  const char* source = 0,
-                  int dep_count = 0,
-                  const char** deps = 0,
-                  int source_length = -1);
+        Extension(const char* name, const char* source = nullptr, int dep_count = 0,
+                  const char** deps = nullptr, int source_length = -1);
         virtual ~Extension() {
             delete source_;
         }
@@ -6597,14 +6438,14 @@ class V8_EXPORT ResourceConstraints {
                                uint64_t virtual_memory_limit);
 
         // Returns the max semi-space size in MB.
-        V8_DEPRECATE_SOON("Use max_semi_space_size_in_kb()",
-                          size_t max_semi_space_size()) {
+        V8_DEPRECATED("Use max_semi_space_size_in_kb()",
+                      size_t max_semi_space_size()) {
             return max_semi_space_size_in_kb_ / 1024;
         }
 
         // Sets the max semi-space size in MB.
-        V8_DEPRECATE_SOON("Use set_max_semi_space_size_in_kb(size_t limit_in_kb)",
-                          void set_max_semi_space_size(size_t limit_in_mb)) {
+        V8_DEPRECATED("Use set_max_semi_space_size_in_kb(size_t limit_in_kb)",
+                      void set_max_semi_space_size(size_t limit_in_mb)) {
             max_semi_space_size_in_kb_ = limit_in_mb * 1024;
         }
 
@@ -6624,12 +6465,12 @@ class V8_EXPORT ResourceConstraints {
         void set_max_old_space_size(size_t limit_in_mb) {
             max_old_space_size_ = limit_in_mb;
         }
-        V8_DEPRECATE_SOON("max_executable_size_ is subsumed by max_old_space_size_",
-                          size_t max_executable_size() const) {
+        V8_DEPRECATED("max_executable_size_ is subsumed by max_old_space_size_",
+                      size_t max_executable_size() const) {
             return max_executable_size_;
         }
-        V8_DEPRECATE_SOON("max_executable_size_ is subsumed by max_old_space_size_",
-                          void set_max_executable_size(size_t limit_in_mb)) {
+        V8_DEPRECATED("max_executable_size_ is subsumed by max_old_space_size_",
+                      void set_max_executable_size(size_t limit_in_mb)) {
             max_executable_size_ = limit_in_mb;
         }
         uint32_t* stack_limit() const {
@@ -6722,7 +6563,6 @@ typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
 // --- Enter/Leave Script Callback ---
 typedef void (*BeforeCallEnteredCallback)(Isolate*);
 typedef void (*CallCompletedCallback)(Isolate*);
-typedef void (*DeprecatedCallCompletedCallback)();
 
 /**
  * HostImportModuleDynamicallyCallback is called when we require the
@@ -6762,6 +6602,15 @@ typedef void (*HostInitializeImportMetaObjectCallback)(Local<Context> context,
         Local<Module> module,
         Local<Object> meta);
 
+/**
+ * PrepareStackTraceCallback is called when the stack property of an error is
+ * first accessed. The return value will be used as the stack value. If this
+ * callback is registed, the |Error.prepareStackTrace| API will be disabled.
+ */
+typedef MaybeLocal<Value> (*PrepareStackTraceCallback)(Local<Context> context,
+        Local<Value> error,
+        Local<StackTrace> trace);
+
 /**
  * PromiseHook with type kInit is called when a new promise is
  * created. When a new promise is created as part of the chain in the
@@ -6902,6 +6751,9 @@ typedef void (*ApiImplementationCallback)(const FunctionCallbackInfo<Value>&);
 // --- Callback for WebAssembly.compileStreaming ---
 typedef void (*WasmStreamingCallback)(const FunctionCallbackInfo<Value>&);
 
+// --- Callback for checking if WebAssembly threads are enabled ---
+typedef bool (*WasmThreadsEnabledCallback)(Local<Context> context);
+
 // --- Garbage Collection Callbacks ---
 
 /**
@@ -6988,6 +6840,9 @@ class V8_EXPORT HeapStatistics {
         size_t malloced_memory() {
             return malloced_memory_;
         }
+        size_t external_memory() {
+            return external_memory_;
+        }
         size_t peak_malloced_memory() {
             return peak_malloced_memory_;
         }
@@ -7014,6 +6869,7 @@ class V8_EXPORT HeapStatistics {
         size_t used_heap_size_;
         size_t heap_size_limit_;
         size_t malloced_memory_;
+        size_t external_memory_;
         size_t peak_malloced_memory_;
         bool does_zap_garbage_;
         size_t number_of_native_contexts_;
@@ -7237,7 +7093,7 @@ typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
  */
 class V8_EXPORT ExternalResourceVisitor {  // NOLINT
     public:
-        virtual ~ExternalResourceVisitor() {}
+        virtual ~ExternalResourceVisitor() = default;
         virtual void VisitExternalString(Local<String> string) {}
 };
 
@@ -7247,7 +7103,7 @@ class V8_EXPORT ExternalResourceVisitor {  // NOLINT
  */
 class V8_EXPORT PersistentHandleVisitor {  // NOLINT
     public:
-        virtual ~PersistentHandleVisitor() {}
+        virtual ~PersistentHandleVisitor() = default;
         virtual void VisitPersistentHandle(Persistent<Value>* value,
                                            uint16_t class_id) {}
 };
@@ -7263,18 +7119,21 @@ class V8_EXPORT PersistentHandleVisitor {  // NOLINT
 enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
 /**
- * Interface for tracing through the embedder heap. During a v8 garbage
- * collection, v8 collects hidden fields of all potential wrappers, and at the
+ * Interface for tracing through the embedder heap. During a V8 garbage
+ * collection, V8 collects hidden fields of all potential wrappers, and at the
  * end of its marking phase iterates the collection and asks the embedder to
  * trace through its heap and use reporter to report each JavaScript object
  * reachable from any of the given wrappers.
- *
- * Before the first call to the TraceWrappersFrom function TracePrologue will be
- * called. When the garbage collection cycle is finished, TraceEpilogue will be
- * called.
  */
 class V8_EXPORT EmbedderHeapTracer {
     public:
+        // Indicator for the stack state of the embedder.
+        enum EmbedderStackState {
+            kUnknown,
+            kNonEmpty,
+            kEmpty,
+        };
+
         enum ForceCompletionAction { FORCE_COMPLETION, DO_NOT_FORCE_COMPLETION };
 
         struct AdvanceTracingActions {
@@ -7284,6 +7143,8 @@ class V8_EXPORT EmbedderHeapTracer {
             ForceCompletionAction force_completion;
         };
 
+        virtual ~EmbedderHeapTracer() = default;
+
         /**
          * Called by v8 to register internal fields of found wrappers.
          *
@@ -7299,7 +7160,7 @@ class V8_EXPORT EmbedderHeapTracer {
         virtual void TracePrologue() = 0;
 
         /**
-         * Called to to make a tracing step in the embedder.
+         * Called to make a tracing step in the embedder.
          *
          * The embedder is expected to trace its heap starting from wrappers reported
          * by RegisterV8References method, and report back all reachable wrappers.
@@ -7307,17 +7168,36 @@ class V8_EXPORT EmbedderHeapTracer {
          * deadline.
          *
          * Returns true if there is still work to do.
+         *
+         * Note: Only one of the AdvanceTracing methods needs to be overriden by the
+         * embedder.
+         */
+        V8_DEPRECATED("Use void AdvanceTracing(deadline_in_ms)",
+                      virtual bool AdvanceTracing(double deadline_in_ms,
+                              AdvanceTracingActions actions)) {
+            return false;
+        }
+
+        /**
+         * Called to advance tracing in the embedder.
+         *
+         * The embedder is expected to trace its heap starting from wrappers reported
+         * by RegisterV8References method, and report back all reachable wrappers.
+         * Furthermore, the embedder is expected to stop tracing by the given
+         * deadline. A deadline of infinity means that tracing should be finished.
+         *
+         * Returns |true| if tracing is done, and false otherwise.
+         *
+         * Note: Only one of the AdvanceTracing methods needs to be overriden by the
+         * embedder.
          */
-        virtual bool AdvanceTracing(double deadline_in_ms,
-                                    AdvanceTracingActions actions) = 0;
+        virtual bool AdvanceTracing(double deadline_in_ms);
 
         /*
          * Returns true if there no more tracing work to be done (see AdvanceTracing)
          * and false otherwise.
          */
-        virtual bool IsTracingDone() {
-            return NumberOfWrappersToTrace() == 0;
-        }
+        virtual bool IsTracingDone();
 
         /**
          * Called at the end of a GC cycle.
@@ -7329,8 +7209,13 @@ class V8_EXPORT EmbedderHeapTracer {
         /**
          * Called upon entering the final marking pause. No more incremental marking
          * steps will follow this call.
+         *
+         * Note: Only one of the EnterFinalPause methods needs to be overriden by the
+         * embedder.
          */
-        virtual void EnterFinalPause() = 0;
+        V8_DEPRECATED("Use void EnterFinalPause(EmbedderStackState)",
+                      virtual void EnterFinalPause()) {}
+        virtual void EnterFinalPause(EmbedderStackState stack_state);
 
         /**
          * Called when tracing is aborted.
@@ -7338,10 +7223,11 @@ class V8_EXPORT EmbedderHeapTracer {
          * The embedder is expected to throw away all intermediate data and reset to
          * the initial state.
          */
-        virtual void AbortTracing() = 0;
+        V8_DEPRECATE_SOON("Obsolete as V8 will not abort tracing anymore.",
+                          virtual void AbortTracing()) {}
 
         /*
-         * Called by the embedder to request immediaet finalization of the currently
+         * Called by the embedder to request immediate finalization of the currently
          * running tracing phase that has been started with TracePrologue and not
          * yet finished with TraceEpilogue.
          *
@@ -7351,6 +7237,13 @@ class V8_EXPORT EmbedderHeapTracer {
          */
         void FinalizeTracing();
 
+        /*
+         * Called by the embedder to immediately perform a full garbage collection.
+         *
+         * Should only be used in testing code.
+         */
+        void GarbageCollectionForTesting(EmbedderStackState stack_state);
+
         /*
          * Returns the v8::Isolate this tracer is attached too and |nullptr| if it
          * is not attached to any v8::Isolate.
@@ -7362,14 +7255,11 @@ class V8_EXPORT EmbedderHeapTracer {
         /**
          * Returns the number of wrappers that are still to be traced by the embedder.
          */
-        V8_DEPRECATE_SOON("Use IsTracingDone",
-        virtual size_t NumberOfWrappersToTrace() {
+        V8_DEPRECATED("Use IsTracingDone", virtual size_t NumberOfWrappersToTrace()) {
             return 0;
-        });
+        }
 
     protected:
-        virtual ~EmbedderHeapTracer() = default;
-
         v8::Isolate* isolate_ = nullptr;
 
         friend class internal::LocalEmbedderHeapTracer;
@@ -7669,6 +7559,25 @@ class V8_EXPORT Isolate {
             kDeoptimizerDisableSpeculation = 47,
             kArrayPrototypeSortJSArrayModifiedPrototype = 48,
             kFunctionTokenOffsetTooLongForToString = 49,
+            kWasmSharedMemory = 50,
+            kWasmThreadOpcodes = 51,
+            kAtomicsNotify = 52,
+            kAtomicsWake = 53,
+            kCollator = 54,
+            kNumberFormat = 55,
+            kDateTimeFormat = 56,
+            kPluralRules = 57,
+            kRelativeTimeFormat = 58,
+            kLocale = 59,
+            kListFormat = 60,
+            kSegmenter = 61,
+            kStringLocaleCompare = 62,
+            kStringToLocaleUpperCase = 63,
+            kStringToLocaleLowerCase = 64,
+            kNumberToLocaleString = 65,
+            kDateToLocaleString = 66,
+            kDateToLocaleDateString = 67,
+            kDateToLocaleTimeString = 68,
 
             // If you add new values here, you'll also need to update Chromium's:
             // web_feature.mojom, UseCounterCallback.cpp, and enums.xml. V8 changes to
@@ -7756,6 +7665,12 @@ class V8_EXPORT Isolate {
         void SetHostInitializeImportMetaObjectCallback(
             HostInitializeImportMetaObjectCallback callback);
 
+        /**
+         * This specifies the callback called when the stack property of Error
+         * is accessed.
+         */
+        void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback);
+
         /**
          * Optional notification that the system is running low on memory.
          * V8 uses these notifications to guide heuristics.
@@ -7937,16 +7852,6 @@ class V8_EXPORT Isolate {
          */
         Local<Context> GetCurrentContext();
 
-        /**
-         * Returns the context of the calling JavaScript code.  That is the
-         * context of the top-most JavaScript frame.  If there are no
-         * JavaScript frames an empty handle is returned.
-         */
-        V8_DEPRECATED(
-            "Calling context concept is not compatible with tail calls, and will be "
-            "removed.",
-            Local<Context> GetCallingContext());
-
         /** Returns the last context entered through V8's C++ API. */
         Local<Context> GetEnteredContext();
 
@@ -8003,6 +7908,11 @@ class V8_EXPORT Isolate {
          */
         void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
 
+        /*
+         * Gets the currently active heap tracer for the isolate.
+         */
+        EmbedderHeapTracer* GetEmbedderHeapTracer();
+
         /**
          * Use for |AtomicsWaitCallback| to indicate the type of event it receives.
          */
@@ -8198,17 +8108,11 @@ class V8_EXPORT Isolate {
          * further callbacks.
          */
         void AddCallCompletedCallback(CallCompletedCallback callback);
-        V8_DEPRECATED(
-            "Use callback with parameter",
-            void AddCallCompletedCallback(DeprecatedCallCompletedCallback callback));
 
         /**
          * Removes callback that was installed by AddCallCompletedCallback.
          */
         void RemoveCallCompletedCallback(CallCompletedCallback callback);
-        V8_DEPRECATED("Use callback with parameter",
-                      void RemoveCallCompletedCallback(
-                          DeprecatedCallCompletedCallback callback));
 
         /**
          * Set the PromiseHook callback for various promise lifecycle
@@ -8242,14 +8146,11 @@ class V8_EXPORT Isolate {
          * Controls how Microtasks are invoked. See MicrotasksPolicy for details.
          */
         void SetMicrotasksPolicy(MicrotasksPolicy policy);
-        V8_DEPRECATED("Use SetMicrotasksPolicy",
-                      void SetAutorunMicrotasks(bool autorun));
 
         /**
          * Returns the policy controlling how Microtasks are invoked.
          */
         MicrotasksPolicy GetMicrotasksPolicy() const;
-        V8_DEPRECATED("Use GetMicrotasksPolicy", bool WillAutorunMicrotasks() const);
 
         /**
          * Adds a callback to notify the host application after
@@ -8410,7 +8311,9 @@ class V8_EXPORT Isolate {
         void SetStackLimit(uintptr_t stack_limit);
 
         /**
-         * Returns a memory range that can potentially contain jitted code.
+         * Returns a memory range that can potentially contain jitted code. Code for
+         * V8's 'builtins' will not be in this range if embedded builtins is enabled.
+         * Instead, see GetEmbeddedCodeRange.
          *
          * On Win64, embedders are advised to install function table callbacks for
          * these ranges, as default SEH won't be able to unwind through jitted code.
@@ -8424,6 +8327,15 @@ class V8_EXPORT Isolate {
          */
         void GetCodeRange(void** start, size_t* length_in_bytes);
 
+        /**
+         * Returns a memory range containing the code for V8's embedded functions
+         * (e.g. builtins) which are shared across isolates.
+         *
+         * If embedded builtins are disabled, then the memory range will be a null
+         * pointer with 0 length.
+         */
+        MemoryRange GetEmbeddedCodeRange();
+
         /** Set the callback to invoke in case of fatal errors. */
         void SetFatalErrorHandler(FatalErrorCallback that);
 
@@ -8472,6 +8384,8 @@ class V8_EXPORT Isolate {
 
         void SetWasmStreamingCallback(WasmStreamingCallback callback);
 
+        void SetWasmThreadsEnabledCallback(WasmThreadsEnabledCallback callback);
+
         /**
         * Check if V8 is dead and therefore unusable.  This is the case after
         * fatal errors such as out-of-memory situations.
@@ -8636,28 +8550,6 @@ class V8_EXPORT V8 {
         static void SetNativesDataBlob(StartupData* startup_blob);
         static void SetSnapshotDataBlob(StartupData* startup_blob);
 
-        /**
-         * Bootstrap an isolate and a context from scratch to create a startup
-         * snapshot. Include the side-effects of running the optional script.
-         * Returns { NULL, 0 } on failure.
-         * The caller acquires ownership of the data array in the return value.
-         */
-        V8_DEPRECATED("Use SnapshotCreator",
-                      static StartupData CreateSnapshotDataBlob(
-                          const char* embedded_source = NULL));
-
-        /**
-         * Bootstrap an isolate and a context from the cold startup blob, run the
-         * warm-up script to trigger code compilation. The side effects are then
-         * discarded. The resulting startup snapshot will include compiled code.
-         * Returns { NULL, 0 } on failure.
-         * The caller acquires ownership of the data array in the return value.
-         * The argument startup blob is untouched.
-         */
-        V8_DEPRECATED("Use SnapshotCreator",
-                      static StartupData WarmUpSnapshotDataBlob(
-                          StartupData cold_startup_blob, const char* warmup_source));
-
         /** Set the callback to invoke in case of Dcheck failures. */
         static void SetDcheckErrorHandler(DcheckErrorCallback that);
 
@@ -9141,7 +9033,6 @@ class V8_EXPORT TryCatch {
          * Returns the .stack property of the thrown object.  If no .stack
          * property is present an empty handle is returned.
          */
-        V8_DEPRECATED("Use maybe version.", Local<Value> StackTrace() const);
         V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace(
             Local<Context> context) const;
 
@@ -9200,8 +9091,8 @@ class V8_EXPORT TryCatch {
          * of the C++ try catch handler itself.
          */
         static void* JSStackComparableAddress(TryCatch* handler) {
-            if (handler == NULL) {
-                return NULL;
+            if (handler == nullptr) {
+                return nullptr;
             }
             return handler->js_stack_comparable_address_;
         }
@@ -9242,7 +9133,7 @@ class V8_EXPORT TryCatch {
  */
 class V8_EXPORT ExtensionConfiguration {
     public:
-        ExtensionConfiguration() : name_count_(0), names_(NULL) { }
+        ExtensionConfiguration() : name_count_(0), names_(nullptr) {}
         ExtensionConfiguration(int name_count, const char* names[])
             : name_count_(name_count), names_(names) { }
 
@@ -9303,7 +9194,7 @@ class V8_EXPORT Context {
          * and only object identify will remain.
          */
         static Local<Context> New(
-            Isolate* isolate, ExtensionConfiguration* extensions = NULL,
+            Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
             MaybeLocal<ObjectTemplate> global_template = MaybeLocal<ObjectTemplate>(),
             MaybeLocal<Value> global_object = MaybeLocal<Value>(),
             DeserializeInternalFieldsCallback internal_fields_deserializer =
@@ -9648,201 +9539,6 @@ class V8_EXPORT Locker {
 
 // --- Implementation ---
 
-
-namespace internal {
-
-/**
- * This class exports constants and functionality from within v8 that
- * is necessary to implement inline functions in the v8 api.  Don't
- * depend on functions and constants defined here.
- */
-class Internals {
-    public:
-        // These values match non-compiler-dependent values defined within
-        // the implementation of v8.
-        static const int kHeapObjectMapOffset = 0;
-        static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSize;
-        static const int kStringResourceOffset = 3 * kApiPointerSize;
-
-        static const int kOddballKindOffset = 4 * kApiPointerSize + kApiDoubleSize;
-        static const int kForeignAddressOffset = kApiPointerSize;
-        static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
-        static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
-        static const int kContextHeaderSize = 2 * kApiPointerSize;
-        static const int kContextEmbedderDataIndex = 5;
-        static const int kFullStringRepresentationMask = 0x0f;
-        static const int kStringEncodingMask = 0x8;
-        static const int kExternalTwoByteRepresentationTag = 0x02;
-        static const int kExternalOneByteRepresentationTag = 0x0a;
-
-        static const int kIsolateEmbedderDataOffset = 0 * kApiPointerSize;
-        static const int kExternalMemoryOffset = 4 * kApiPointerSize;
-        static const int kExternalMemoryLimitOffset =
-            kExternalMemoryOffset + kApiInt64Size;
-        static const int kExternalMemoryAtLastMarkCompactOffset =
-            kExternalMemoryLimitOffset + kApiInt64Size;
-        static const int kIsolateRootsOffset = kExternalMemoryLimitOffset +
-                                               kApiInt64Size + kApiInt64Size +
-                                               kApiPointerSize + kApiPointerSize;
-        static const int kUndefinedValueRootIndex = 4;
-        static const int kTheHoleValueRootIndex = 5;
-        static const int kNullValueRootIndex = 6;
-        static const int kTrueValueRootIndex = 7;
-        static const int kFalseValueRootIndex = 8;
-        static const int kEmptyStringRootIndex = 9;
-
-        static const int kNodeClassIdOffset = 1 * kApiPointerSize;
-        static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
-        static const int kNodeStateMask = 0x7;
-        static const int kNodeStateIsWeakValue = 2;
-        static const int kNodeStateIsPendingValue = 3;
-        static const int kNodeStateIsNearDeathValue = 4;
-        static const int kNodeIsIndependentShift = 3;
-        static const int kNodeIsActiveShift = 4;
-
-        static const int kFirstNonstringType = 0x80;
-        static const int kOddballType = 0x83;
-        static const int kForeignType = 0x87;
-        static const int kJSSpecialApiObjectType = 0x410;
-        static const int kJSApiObjectType = 0x420;
-        static const int kJSObjectType = 0x421;
-
-        static const int kUndefinedOddballKind = 5;
-        static const int kNullOddballKind = 3;
-
-        static const uint32_t kNumIsolateDataSlots = 4;
-
-        V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
-        V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
-#ifdef V8_ENABLE_CHECKS
-            CheckInitializedImpl(isolate);
-#endif
-        }
-
-        V8_INLINE static bool HasHeapObjectTag(const internal::Object* value) {
-            return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
-                    kHeapObjectTag);
-        }
-
-        V8_INLINE static int SmiValue(const internal::Object* value) {
-            return PlatformSmiTagging::SmiToInt(value);
-        }
-
-        V8_INLINE static internal::Object* IntToSmi(int value) {
-            return PlatformSmiTagging::IntToSmi(value);
-        }
-
-        V8_INLINE static bool IsValidSmi(intptr_t value) {
-            return PlatformSmiTagging::IsValidSmi(value);
-        }
-
-        V8_INLINE static int GetInstanceType(const internal::Object* obj) {
-            typedef internal::Object O;
-            O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
-            return ReadField<uint16_t>(map, kMapInstanceTypeOffset);
-        }
-
-        V8_INLINE static int GetOddballKind(const internal::Object* obj) {
-            typedef internal::Object O;
-            return SmiValue(ReadField<O*>(obj, kOddballKindOffset));
-        }
-
-        V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
-            int representation = (instance_type & kFullStringRepresentationMask);
-            return representation == kExternalTwoByteRepresentationTag;
-        }
-
-        V8_INLINE static uint8_t GetNodeFlag(internal::Object** obj, int shift) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
-            return *addr & static_cast<uint8_t>(1U << shift);
-        }
-
-        V8_INLINE static void UpdateNodeFlag(internal::Object** obj,
-                                             bool value, int shift) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
-            uint8_t mask = static_cast<uint8_t>(1U << shift);
-            *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
-        }
-
-        V8_INLINE static uint8_t GetNodeState(internal::Object** obj) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
-            return *addr & kNodeStateMask;
-        }
-
-        V8_INLINE static void UpdateNodeState(internal::Object** obj,
-                                              uint8_t value) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
-            *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
-        }
-
-        V8_INLINE static void SetEmbedderData(v8::Isolate* isolate,
-                                              uint32_t slot,
-                                              void* data) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
-                            kIsolateEmbedderDataOffset + slot * kApiPointerSize;
-            *reinterpret_cast<void**>(addr) = data;
-        }
-
-        V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
-                                               uint32_t slot) {
-            const uint8_t* addr = reinterpret_cast<const uint8_t*>(isolate) +
-                                  kIsolateEmbedderDataOffset + slot * kApiPointerSize;
-            return *reinterpret_cast<void* const*>(addr);
-        }
-
-        V8_INLINE static internal::Object** GetRoot(v8::Isolate* isolate,
-                int index) {
-            uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) + kIsolateRootsOffset;
-            return reinterpret_cast<internal::Object**>(addr + index * kApiPointerSize);
-        }
-
-        template <typename T>
-        V8_INLINE static T ReadField(const internal::Object* ptr, int offset) {
-            const uint8_t* addr =
-                reinterpret_cast<const uint8_t*>(ptr) + offset - kHeapObjectTag;
-            return *reinterpret_cast<const T*>(addr);
-        }
-
-        template <typename T>
-        V8_INLINE static T ReadEmbedderData(const v8::Context* context, int index) {
-            typedef internal::Object O;
-            typedef internal::Internals I;
-            O* ctx = *reinterpret_cast<O* const*>(context);
-            int embedder_data_offset = I::kContextHeaderSize +
-                                       (internal::kApiPointerSize * I::kContextEmbedderDataIndex);
-            O* embedder_data = I::ReadField<O*>(ctx, embedder_data_offset);
-            int value_offset =
-                I::kFixedArrayHeaderSize + (internal::kApiPointerSize * index);
-            return I::ReadField<T>(embedder_data, value_offset);
-        }
-};
-
-// Only perform cast check for types derived from v8::Data since
-// other types do not implement the Cast method.
-template <bool PerformCheck>
-struct CastCheck {
-    template <class T>
-    static void Perform(T* data);
-};
-
-template <>
-template <class T>
-void CastCheck<true>::Perform(T* data) {
-    T::Cast(data);
-}
-
-template <>
-template <class T>
-void CastCheck<false>::Perform(T* data) {}
-
-template <class T>
-V8_INLINE void PerformCastCheck(T* data) {
-    CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
-}
-
-}  // namespace internal
-
-
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, Local<T> that) {
     return New(isolate, that.val_);
@@ -9856,7 +9552,7 @@ Local<T> Local<T>::New(Isolate* isolate, const PersistentBase<T>& that) {
 
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, T* that) {
-    if (that == NULL) {
+    if (that == nullptr) {
         return Local<T>();
     }
     T* that_ptr = that;
@@ -9904,8 +9600,8 @@ void* WeakCallbackInfo<T>::GetInternalField(int index) const {
 
 template <class T>
 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
-    if (that == NULL) {
-        return NULL;
+    if (that == nullptr) {
+        return nullptr;
     }
     internal::Object** p = reinterpret_cast<internal::Object**>(that);
     return reinterpret_cast<T*>(
@@ -9967,7 +9663,7 @@ void PersistentBase<T>::Reset() {
         return;
     }
     V8::DisposeGlobal(reinterpret_cast<internal::Object**>(this->val_));
-    val_ = 0;
+    val_ = nullptr;
 }
 
 
@@ -10445,12 +10141,13 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
     typedef internal::Object O;
     typedef internal::Internals I;
     O* obj = *reinterpret_cast<O* const*>(this);
-    String::ExternalStringResource* result;
+
+    ExternalStringResource* result;
     if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
         void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
         result = reinterpret_cast<String::ExternalStringResource*>(value);
     } else {
-        result = NULL;
+        result = GetExternalStringResourceSlow();
     }
 #ifdef V8_ENABLE_CHECKS
     VerifyExternalStringResource(result);
@@ -10466,11 +10163,13 @@ String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
     O* obj = *reinterpret_cast<O* const*>(this);
     int type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
     *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
-    ExternalStringResourceBase* resource = NULL;
+    ExternalStringResourceBase* resource;
     if (type == I::kExternalOneByteRepresentationTag ||
             type == I::kExternalTwoByteRepresentationTag) {
         void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
         resource = static_cast<ExternalStringResourceBase*>(value);
+    } else {
+        resource = GetExternalStringResourceBaseSlow(encoding_out);
     }
 #ifdef V8_ENABLE_CHECKS
     VerifyExternalStringResourceBase(resource, *encoding_out);
@@ -10568,30 +10267,6 @@ template <class T> Value* Value::Cast(T* value) {
 }
 
 
-Local<Boolean> Value::ToBoolean() const {
-    return ToBoolean(Isolate::GetCurrent()->GetCurrentContext())
-           .FromMaybe(Local<Boolean>());
-}
-
-
-Local<String> Value::ToString() const {
-    return ToString(Isolate::GetCurrent()->GetCurrentContext())
-           .FromMaybe(Local<String>());
-}
-
-
-Local<Object> Value::ToObject() const {
-    return ToObject(Isolate::GetCurrent()->GetCurrentContext())
-           .FromMaybe(Local<Object>());
-}
-
-
-Local<Integer> Value::ToInteger() const {
-    return ToInteger(Isolate::GetCurrent()->GetCurrentContext())
-           .FromMaybe(Local<Integer>());
-}
-
-
 Boolean* Boolean::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -11042,10 +10717,11 @@ int64_t Isolate::AdjustAmountOfExternalAllocatedMemory(
     }
 
     if (change_in_bytes < 0) {
-        *external_memory_limit += change_in_bytes;
-    }
-
-    if (change_in_bytes > 0 && amount > *external_memory_limit) {
+        const int64_t lower_limit = *external_memory_limit + change_in_bytes;
+        if (lower_limit > I::kExternalAllocationSoftLimit) {
+            *external_memory_limit = lower_limit;
+        }
+    } else if (change_in_bytes > 0 && amount > *external_memory_limit) {
         ReportExternalAllocationLimitReached();
     }
     return *external_memory;
diff --git a/test-app/runtime/src/main/cpp/include/v8config.h b/test-app/runtime/src/main/cpp/include/v8config.h
index 8bbd9d878..3e576765c 100644
--- a/test-app/runtime/src/main/cpp/include/v8config.h
+++ b/test-app/runtime/src/main/cpp/include/v8config.h
@@ -214,6 +214,8 @@
 # define V8_HAS_ATTRIBUTE_ALIGNED (__has_attribute(aligned))
 # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline))
 # define V8_HAS_ATTRIBUTE_DEPRECATED (__has_attribute(deprecated))
+# define V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE \
+    (__has_extension(attribute_deprecated_with_message))
 # define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline))
 # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
 # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
@@ -423,6 +425,36 @@ template <typename T> class AlignOfHelper {
 #define V8_WARN_UNUSED_RESULT /* NOT SUPPORTED */
 #endif
 
+#ifdef V8_OS_WIN
+
+// Setup for Windows DLL export/import. When building the V8 DLL the
+// BUILDING_V8_SHARED needs to be defined. When building a program which uses
+// the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
+// static library or building a program which uses the V8 static library neither
+// BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
+#ifdef BUILDING_V8_SHARED
+# define V8_EXPORT __declspec(dllexport)
+#elif USING_V8_SHARED
+# define V8_EXPORT __declspec(dllimport)
+#else
+# define V8_EXPORT
+#endif  // BUILDING_V8_SHARED
+
+#else  // V8_OS_WIN
+
+// Setup for Linux shared library export.
+#if V8_HAS_ATTRIBUTE_VISIBILITY
+# ifdef BUILDING_V8_SHARED
+#  define V8_EXPORT __attribute__ ((visibility("default")))
+# else
+#  define V8_EXPORT
+# endif
+#else
+# define V8_EXPORT
+#endif
+
+#endif  // V8_OS_WIN
+
 // clang-format on
 
 #endif  // V8CONFIG_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/allocation.h b/test-app/runtime/src/main/cpp/v8_inspector/src/allocation.h
index 83eb9919d..4bf9b2dd6 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/allocation.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/allocation.h
@@ -6,6 +6,7 @@
 #define V8_ALLOCATION_H_
 
 #include "include/v8-platform.h"
+#include "src/base/address-region.h"
 #include "src/base/compiler-specific.h"
 #include "src/base/platform/platform.h"
 #include "src/globals.h"
@@ -94,6 +95,9 @@ void* AllocWithRetry(size_t size);
 void* AlignedAlloc(size_t size, size_t alignment);
 void AlignedFree(void* ptr);
 
+// Returns platfrom page allocator instance. Guaranteed to be a valid pointer.
+V8_EXPORT_PRIVATE v8::PageAllocator* GetPlatformPageAllocator();
+
 // Gets the page granularity for AllocatePages and FreePages. Addresses returned
 // by AllocatePages and AllocatePage are aligned to this size.
 V8_EXPORT_PRIVATE size_t AllocatePageSize();
@@ -113,14 +117,16 @@ V8_EXPORT_PRIVATE void* GetRandomMmapAddr();
 // AllocatePageSize(). Returns the address of the allocated memory, with the
 // specified size and alignment, or nullptr on failure.
 V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT void* AllocatePages(void* address, size_t size,
+V8_WARN_UNUSED_RESULT void* AllocatePages(v8::PageAllocator* page_allocator,
+        void* address, size_t size,
         size_t alignment,
         PageAllocator::Permission access);
 
 // Frees memory allocated by a call to AllocatePages. |address| and |size| must
 // be multiples of AllocatePageSize(). Returns true on success, otherwise false.
 V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool FreePages(void* address, const size_t size);
+V8_WARN_UNUSED_RESULT bool FreePages(v8::PageAllocator* page_allocator,
+                                     void* address, const size_t size);
 
 // Releases memory that is no longer needed. The range specified by |address|
 // and |size| must be an allocated memory region. |size| and |new_size| must be
@@ -128,7 +134,8 @@ V8_WARN_UNUSED_RESULT bool FreePages(void* address, const size_t size);
 // Released memory is left in an undefined state, so it should not be accessed.
 // Returns true on success, otherwise false.
 V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool ReleasePages(void* address, size_t size,
+V8_WARN_UNUSED_RESULT bool ReleasePages(v8::PageAllocator* page_allocator,
+                                        void* address, size_t size,
                                         size_t new_size);
 
 // Sets permissions according to |access|. |address| and |size| must be
@@ -136,18 +143,21 @@ V8_WARN_UNUSED_RESULT bool ReleasePages(void* address, size_t size,
 // cause the memory contents to be lost. Returns true on success, otherwise
 // false.
 V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool SetPermissions(void* address, size_t size,
+V8_WARN_UNUSED_RESULT bool SetPermissions(v8::PageAllocator* page_allocator,
+        void* address, size_t size,
         PageAllocator::Permission access);
-inline bool SetPermissions(Address address, size_t size,
-                           PageAllocator::Permission access) {
-    return SetPermissions(reinterpret_cast<void*>(address), size, access);
+inline bool SetPermissions(v8::PageAllocator* page_allocator, Address address,
+                           size_t size, PageAllocator::Permission access) {
+    return SetPermissions(page_allocator, reinterpret_cast<void*>(address), size,
+                          access);
 }
 
 // Convenience function that allocates a single system page with read and write
 // permissions. |address| is a hint. Returns the base address of the memory and
 // the page size via |allocated| on success. Returns nullptr on failure.
 V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT byte* AllocatePage(void* address, size_t* allocated);
+V8_WARN_UNUSED_RESULT byte* AllocatePage(v8::PageAllocator* page_allocator,
+        void* address, size_t* allocated);
 
 // Function that may release reserved memory regions to allow failed allocations
 // to succeed. |length| is the amount of memory needed. Returns |true| if memory
@@ -155,45 +165,66 @@ V8_WARN_UNUSED_RESULT byte* AllocatePage(void* address, size_t* allocated);
 V8_EXPORT_PRIVATE bool OnCriticalMemoryPressure(size_t length);
 
 // Represents and controls an area of reserved memory.
-class V8_EXPORT_PRIVATE VirtualMemory {
+class V8_EXPORT_PRIVATE VirtualMemory final {
     public:
         // Empty VirtualMemory object, controlling no reserved memory.
-        VirtualMemory();
+        VirtualMemory() = default;
 
         // Reserves virtual memory containing an area of the given size that is
-        // aligned per alignment. This may not be at the position returned by
-        // address().
-        VirtualMemory(size_t size, void* hint, size_t alignment = AllocatePageSize());
+        // aligned per |alignment| rounded up to the |page_allocator|'s allocate page
+        // size.
+        // This may not be at the position returned by address().
+        VirtualMemory(v8::PageAllocator* page_allocator, size_t size, void* hint,
+                      size_t alignment = 1);
 
         // Construct a virtual memory by assigning it some already mapped address
         // and size.
-        VirtualMemory(Address address, size_t size)
-            : address_(address), size_(size) {}
+        VirtualMemory(v8::PageAllocator* page_allocator, Address address, size_t size)
+            : page_allocator_(page_allocator), region_(address, size) {
+            DCHECK_NOT_NULL(page_allocator);
+        }
 
         // Releases the reserved memory, if any, controlled by this VirtualMemory
         // object.
         ~VirtualMemory();
 
+        // Move constructor.
+        VirtualMemory(VirtualMemory&& other) V8_NOEXCEPT { TakeControl(&other); }
+
+        // Move assignment operator.
+        VirtualMemory& operator=(VirtualMemory&& other) V8_NOEXCEPT {
+            TakeControl(&other);
+            return *this;
+        }
+
         // Returns whether the memory has been reserved.
         bool IsReserved() const {
-            return address_ != kNullAddress;
+            return region_.begin() != kNullAddress;
         }
 
         // Initialize or resets an embedded VirtualMemory object.
         void Reset();
 
+        v8::PageAllocator* page_allocator() {
+            return page_allocator_;
+        }
+
+        const base::AddressRegion& region() const {
+            return region_;
+        }
+
         // Returns the start address of the reserved memory.
         // If the memory was reserved with an alignment, this address is not
         // necessarily aligned. The user might need to round it up to a multiple of
         // the alignment to get the start of the aligned block.
         Address address() const {
             DCHECK(IsReserved());
-            return address_;
+            return region_.begin();
         }
 
         Address end() const {
             DCHECK(IsReserved());
-            return address_ + size_;
+            return region_.end();
         }
 
         // Returns the size of the reserved memory. The returned value is only
@@ -201,7 +232,7 @@ class V8_EXPORT_PRIVATE VirtualMemory {
         // If the memory was reserved with an alignment, this size may be larger
         // than the requested size.
         size_t size() const {
-            return size_;
+            return region_.size();
         }
 
         // Sets permissions according to the access argument. address and size must be
@@ -220,17 +251,16 @@ class V8_EXPORT_PRIVATE VirtualMemory {
         void TakeControl(VirtualMemory* from);
 
         bool InVM(Address address, size_t size) {
-            return (address_ <= address) && ((address_ + size_) >= (address + size));
+            return region_.contains(address, size);
         }
 
     private:
-        Address address_;  // Start address of the virtual memory.
-        size_t size_;    // Size of the virtual memory.
-};
+        // Page allocator that controls the virtual memory.
+        v8::PageAllocator* page_allocator_ = nullptr;
+        base::AddressRegion region_;
 
-bool AllocVirtualMemory(size_t size, void* hint, VirtualMemory* result);
-bool AlignedAllocVirtualMemory(size_t size, size_t alignment, void* hint,
-                               VirtualMemory* result);
+        DISALLOW_COPY_AND_ASSIGN(VirtualMemory);
+};
 
 }  // namespace internal
 }  // namespace v8
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/address-region.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/address-region.h
new file mode 100644
index 000000000..5ce85cb30
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/address-region.h
@@ -0,0 +1,80 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASE_ADDRESS_REGION_H_
+#define V8_BASE_ADDRESS_REGION_H_
+
+#include <iostream>
+
+#include "src/base/macros.h"
+
+namespace v8 {
+namespace base {
+
+// Helper class representing an address region of certain size.
+class AddressRegion {
+    public:
+        typedef uintptr_t Address;
+
+        AddressRegion() = default;
+
+        AddressRegion(Address address, size_t size)
+            : address_(address), size_(size) {}
+
+        Address begin() const {
+            return address_;
+        }
+        Address end() const {
+            return address_ + size_;
+        }
+
+        size_t size() const {
+            return size_;
+        }
+        void set_size(size_t size) {
+            size_ = size;
+        }
+
+        bool is_empty() const {
+            return size_ == 0;
+        }
+
+        bool contains(Address address) const {
+            STATIC_ASSERT(std::is_unsigned<Address>::value);
+            return (address - begin()) < size();
+        }
+
+        bool contains(Address address, size_t size) const {
+            STATIC_ASSERT(std::is_unsigned<Address>::value);
+            Address offset = address - begin();
+            return (offset < size_) && (offset + size <= size_);
+        }
+
+        bool contains(AddressRegion region) const {
+            return contains(region.address_, region.size_);
+        }
+
+        bool operator==(AddressRegion other) const {
+            return address_ == other.address_ && size_ == other.size_;
+        }
+
+        bool operator!=(AddressRegion other) const {
+            return address_ != other.address_ || size_ != other.size_;
+        }
+
+    private:
+        Address address_ = 0;
+        size_t size_ = 0;
+};
+ASSERT_TRIVIALLY_COPYABLE(AddressRegion);
+
+inline std::ostream& operator<<(std::ostream& out, AddressRegion region) {
+    return out << "[" << reinterpret_cast<void*>(region.begin()) << "+"
+           << region.size() << "]";
+}
+
+}  // namespace base
+}  // namespace v8
+
+#endif  // V8_BASE_ADDRESS_REGION_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/atomic-utils.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/atomic-utils.h
index ce1ba3c38..38b16f6da 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/atomic-utils.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/atomic-utils.h
@@ -385,6 +385,22 @@ class AtomicElement {
         T value_;
 };
 
+template <typename T,
+          typename = typename std::enable_if<std::is_unsigned<T>::value>::type>
+inline void CheckedIncrement(std::atomic<T>* number, T amount) {
+    const T old = number->fetch_add(amount);
+    DCHECK_GE(old + amount, old);
+    USE(old);
+}
+
+template <typename T,
+          typename = typename std::enable_if<std::is_unsigned<T>::value>::type>
+inline void CheckedDecrement(std::atomic<T>* number, T amount) {
+    const T old = number->fetch_sub(amount);
+    DCHECK_GE(old, amount);
+    USE(old);
+}
+
 }  // namespace base
 }  // namespace v8
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/bits.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/bits.h
index 731a7181d..6cd509bb7 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/bits.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/bits.h
@@ -30,40 +30,44 @@ namespace bits {
 // CountPopulation(value) returns the number of bits set in |value|.
 template <typename T>
 constexpr inline
-    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountPopulation(T value) {
+typename std::enable_if<std::is_unsigned<T>::value&& sizeof(T) <= 8,
+         unsigned>::type
+CountPopulation(T value) {
 #if V8_HAS_BUILTIN_POPCOUNT
-  return sizeof(T) == 8 ? __builtin_popcountll(static_cast<uint64_t>(value))
-                        : __builtin_popcount(static_cast<uint32_t>(value));
+    return sizeof(T) == 8 ? __builtin_popcountll(static_cast<uint64_t>(value))
+           : __builtin_popcount(static_cast<uint32_t>(value));
 #else
-  constexpr uint64_t mask[] = {0x5555555555555555, 0x3333333333333333,
-                               0x0f0f0f0f0f0f0f0f, 0x00ff00ff00ff00ff,
-                               0x0000ffff0000ffff, 0x00000000ffffffff};
-  value = ((value >> 1) & mask[0]) + (value & mask[0]);
-  value = ((value >> 2) & mask[1]) + (value & mask[1]);
-  value = ((value >> 4) & mask[2]) + (value & mask[2]);
-  if (sizeof(T) > 1)
-    value = ((value >> (sizeof(T) > 1 ? 8 : 0)) & mask[3]) + (value & mask[3]);
-  if (sizeof(T) > 2)
-    value = ((value >> (sizeof(T) > 2 ? 16 : 0)) & mask[4]) + (value & mask[4]);
-  if (sizeof(T) > 4)
-    value = ((value >> (sizeof(T) > 4 ? 32 : 0)) & mask[5]) + (value & mask[5]);
-  return static_cast<unsigned>(value);
+    constexpr uint64_t mask[] = {0x5555555555555555, 0x3333333333333333,
+                                 0x0f0f0f0f0f0f0f0f, 0x00ff00ff00ff00ff,
+                                 0x0000ffff0000ffff, 0x00000000ffffffff
+                                };
+    value = ((value >> 1) & mask[0]) + (value & mask[0]);
+    value = ((value >> 2) & mask[1]) + (value & mask[1]);
+    value = ((value >> 4) & mask[2]) + (value & mask[2]);
+    if (sizeof(T) > 1) {
+        value = ((value >> (sizeof(T) > 1 ? 8 : 0)) & mask[3]) + (value & mask[3]);
+    }
+    if (sizeof(T) > 2) {
+        value = ((value >> (sizeof(T) > 2 ? 16 : 0)) & mask[4]) + (value & mask[4]);
+    }
+    if (sizeof(T) > 4) {
+        value = ((value >> (sizeof(T) > 4 ? 32 : 0)) & mask[5]) + (value & mask[5]);
+    }
+    return static_cast<unsigned>(value);
 #endif
 }
 
 // ReverseBits(value) returns |value| in reverse bit order.
 template <typename T>
 T ReverseBits(T value) {
-  DCHECK((sizeof(value) == 1) || (sizeof(value) == 2) || (sizeof(value) == 4) ||
-         (sizeof(value) == 8));
-  T result = 0;
-  for (unsigned i = 0; i < (sizeof(value) * 8); i++) {
-    result = (result << 1) | (value & 1);
-    value >>= 1;
-  }
-  return result;
+    DCHECK((sizeof(value) == 1) || (sizeof(value) == 2) || (sizeof(value) == 4) ||
+           (sizeof(value) == 8));
+    T result = 0;
+    for (unsigned i = 0; i < (sizeof(value) * 8); i++) {
+        result = (result << 1) | (value & 1);
+        value >>= 1;
+    }
+    return result;
 }
 
 // CountLeadingZeros(value) returns the number of zero bits following the most
@@ -71,33 +75,35 @@ T ReverseBits(T value) {
 // {sizeof(T) * 8}.
 template <typename T, unsigned bits = sizeof(T) * 8>
 inline constexpr
-    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountLeadingZeros(T value) {
-  static_assert(bits > 0, "invalid instantiation");
+typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
+         unsigned>::type
+CountLeadingZeros(T value) {
+    static_assert(bits > 0, "invalid instantiation");
 #if V8_HAS_BUILTIN_CLZ
-  return value == 0
-             ? bits
-             : bits == 64
-                   ? __builtin_clzll(static_cast<uint64_t>(value))
-                   : __builtin_clz(static_cast<uint32_t>(value)) - (32 - bits);
+    return value == 0
+           ? bits
+           : bits == 64
+           ? __builtin_clzll(static_cast<uint64_t>(value))
+           : __builtin_clz(static_cast<uint32_t>(value)) - (32 - bits);
 #else
-  // Binary search algorithm taken from "Hacker's Delight" (by Henry S. Warren,
-  // Jr.), figures 5-11 and 5-12.
-  if (bits == 1) return static_cast<unsigned>(value) ^ 1;
-  T upper_half = value >> (bits / 2);
-  T next_value = upper_half != 0 ? upper_half : value;
-  unsigned add = upper_half != 0 ? 0 : bits / 2;
-  constexpr unsigned next_bits = bits == 1 ? 1 : bits / 2;
-  return CountLeadingZeros<T, next_bits>(next_value) + add;
+    // Binary search algorithm taken from "Hacker's Delight" (by Henry S. Warren,
+    // Jr.), figures 5-11 and 5-12.
+    if (bits == 1) {
+        return static_cast<unsigned>(value) ^ 1;
+    }
+    T upper_half = value >> (bits / 2);
+    T next_value = upper_half != 0 ? upper_half : value;
+    unsigned add = upper_half != 0 ? 0 : bits / 2;
+    constexpr unsigned next_bits = bits == 1 ? 1 : bits / 2;
+    return CountLeadingZeros<T, next_bits>(next_value) + add;
 #endif
 }
 
 inline constexpr unsigned CountLeadingZeros32(uint32_t value) {
-  return CountLeadingZeros(value);
+    return CountLeadingZeros(value);
 }
 inline constexpr unsigned CountLeadingZeros64(uint64_t value) {
-  return CountLeadingZeros(value);
+    return CountLeadingZeros(value);
 }
 
 // CountTrailingZeros(value) returns the number of zero bits preceding the
@@ -105,36 +111,36 @@ inline constexpr unsigned CountLeadingZeros64(uint64_t value) {
 // returns {sizeof(T) * 8}.
 template <typename T, unsigned bits = sizeof(T) * 8>
 inline constexpr
-    typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountTrailingZeros(T value) {
+typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
+         unsigned>::type
+CountTrailingZeros(T value) {
 #if V8_HAS_BUILTIN_CTZ
-  return value == 0 ? bits
-                    : bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
-                                 : __builtin_ctz(static_cast<uint32_t>(value));
+    return value == 0 ? bits
+           : bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
+           : __builtin_ctz(static_cast<uint32_t>(value));
 #else
-  // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
-  // chapter 5-4. On x64, since is faster than counting in a loop and faster
-  // than doing binary search.
-  using U = typename std::make_unsigned<T>::type;
-  U u = value;
-  return CountPopulation(static_cast<U>(~u & (u - 1u)));
+    // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
+    // chapter 5-4. On x64, since is faster than counting in a loop and faster
+    // than doing binary search.
+    using U = typename std::make_unsigned<T>::type;
+    U u = value;
+    return CountPopulation(static_cast<U>(~u & (u - 1u)));
 #endif
 }
 
 inline constexpr unsigned CountTrailingZeros32(uint32_t value) {
-  return CountTrailingZeros(value);
+    return CountTrailingZeros(value);
 }
 inline constexpr unsigned CountTrailingZeros64(uint64_t value) {
-  return CountTrailingZeros(value);
+    return CountTrailingZeros(value);
 }
 
 // Returns true iff |value| is a power of 2.
 template <typename T,
           typename = typename std::enable_if<std::is_integral<T>::value ||
-                                             std::is_enum<T>::value>::type>
+                  std::is_enum<T>::value>::type>
 constexpr inline bool IsPowerOfTwo(T value) {
-  return value > 0 && (value & (value - 1)) == 0;
+    return value > 0 && (value & (value - 1)) == 0;
 }
 
 // RoundUpToPowerOfTwo32(value) returns the smallest power of two which is
@@ -146,40 +152,60 @@ constexpr inline bool IsPowerOfTwo(T value) {
 V8_BASE_EXPORT uint32_t RoundUpToPowerOfTwo32(uint32_t value);
 // Same for 64 bit integers. |value| must be <= 2^63
 V8_BASE_EXPORT uint64_t RoundUpToPowerOfTwo64(uint64_t value);
+// Same for size_t integers.
+inline size_t RoundUpToPowerOfTwo(size_t value) {
+    if (sizeof(size_t) == sizeof(uint64_t)) {
+        return RoundUpToPowerOfTwo64(value);
+    } else {
+        return RoundUpToPowerOfTwo32(value);
+    }
+}
 
 // RoundDownToPowerOfTwo32(value) returns the greatest power of two which is
 // less than or equal to |value|. If you pass in a |value| that is already a
 // power of two, it is returned as is.
 inline uint32_t RoundDownToPowerOfTwo32(uint32_t value) {
-  if (value > 0x80000000u) return 0x80000000u;
-  uint32_t result = RoundUpToPowerOfTwo32(value);
-  if (result > value) result >>= 1;
-  return result;
+    if (value > 0x80000000u) {
+        return 0x80000000u;
+    }
+    uint32_t result = RoundUpToPowerOfTwo32(value);
+    if (result > value) {
+        result >>= 1;
+    }
+    return result;
 }
 
 
 // Precondition: 0 <= shift < 32
 inline uint32_t RotateRight32(uint32_t value, uint32_t shift) {
-  if (shift == 0) return value;
-  return (value >> shift) | (value << (32 - shift));
+    if (shift == 0) {
+        return value;
+    }
+    return (value >> shift) | (value << (32 - shift));
 }
 
 // Precondition: 0 <= shift < 32
 inline uint32_t RotateLeft32(uint32_t value, uint32_t shift) {
-  if (shift == 0) return value;
-  return (value << shift) | (value >> (32 - shift));
+    if (shift == 0) {
+        return value;
+    }
+    return (value << shift) | (value >> (32 - shift));
 }
 
 // Precondition: 0 <= shift < 64
 inline uint64_t RotateRight64(uint64_t value, uint64_t shift) {
-  if (shift == 0) return value;
-  return (value >> shift) | (value << (64 - shift));
+    if (shift == 0) {
+        return value;
+    }
+    return (value >> shift) | (value << (64 - shift));
 }
 
 // Precondition: 0 <= shift < 64
 inline uint64_t RotateLeft64(uint64_t value, uint64_t shift) {
-  if (shift == 0) return value;
-  return (value << shift) | (value >> (64 - shift));
+    if (shift == 0) {
+        return value;
+    }
+    return (value << shift) | (value >> (64 - shift));
 }
 
 
@@ -188,11 +214,11 @@ inline uint64_t RotateLeft64(uint64_t value, uint64_t shift) {
 // returns true if the signed summation resulted in an overflow.
 inline bool SignedAddOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
 #if V8_HAS_BUILTIN_SADD_OVERFLOW
-  return __builtin_sadd_overflow(lhs, rhs, val);
+    return __builtin_sadd_overflow(lhs, rhs, val);
 #else
-  uint32_t res = static_cast<uint32_t>(lhs) + static_cast<uint32_t>(rhs);
-  *val = bit_cast<int32_t>(res);
-  return ((res ^ lhs) & (res ^ rhs) & (1U << 31)) != 0;
+    uint32_t res = static_cast<uint32_t>(lhs) + static_cast<uint32_t>(rhs);
+    *val = bit_cast<int32_t>(res);
+    return ((res ^ lhs) & (res ^ rhs) & (1U << 31)) != 0;
 #endif
 }
 
@@ -202,11 +228,11 @@ inline bool SignedAddOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
 // returns true if the signed subtraction resulted in an overflow.
 inline bool SignedSubOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
 #if V8_HAS_BUILTIN_SSUB_OVERFLOW
-  return __builtin_ssub_overflow(lhs, rhs, val);
+    return __builtin_ssub_overflow(lhs, rhs, val);
 #else
-  uint32_t res = static_cast<uint32_t>(lhs) - static_cast<uint32_t>(rhs);
-  *val = bit_cast<int32_t>(res);
-  return ((res ^ lhs) & (res ^ ~rhs) & (1U << 31)) != 0;
+    uint32_t res = static_cast<uint32_t>(lhs) - static_cast<uint32_t>(rhs);
+    *val = bit_cast<int32_t>(res);
+    return ((res ^ lhs) & (res ^ ~rhs) & (1U << 31)) != 0;
 #endif
 }
 
@@ -219,9 +245,9 @@ V8_BASE_EXPORT bool SignedMulOverflow32(int32_t lhs, int32_t rhs, int32_t* val);
 // |rhs| and stores the result into the variable pointed to by |val| and
 // returns true if the signed summation resulted in an overflow.
 inline bool SignedAddOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
-  uint64_t res = static_cast<uint64_t>(lhs) + static_cast<uint64_t>(rhs);
-  *val = bit_cast<int64_t>(res);
-  return ((res ^ lhs) & (res ^ rhs) & (1ULL << 63)) != 0;
+    uint64_t res = static_cast<uint64_t>(lhs) + static_cast<uint64_t>(rhs);
+    *val = bit_cast<int64_t>(res);
+    return ((res ^ lhs) & (res ^ rhs) & (1ULL << 63)) != 0;
 }
 
 
@@ -229,9 +255,9 @@ inline bool SignedAddOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
 // |rhs| and stores the result into the variable pointed to by |val| and
 // returns true if the signed subtraction resulted in an overflow.
 inline bool SignedSubOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
-  uint64_t res = static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs);
-  *val = bit_cast<int64_t>(res);
-  return ((res ^ lhs) & (res ^ ~rhs) & (1ULL << 63)) != 0;
+    uint64_t res = static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs);
+    *val = bit_cast<int64_t>(res);
+    return ((res ^ lhs) & (res ^ ~rhs) & (1ULL << 63)) != 0;
 }
 
 // SignedMulOverflow64(lhs,rhs,val) performs a signed multiplication of |lhs|
@@ -248,7 +274,7 @@ V8_BASE_EXPORT int32_t SignedMulHigh32(int32_t lhs, int32_t rhs);
 // |lhs| and |rhs|, extracts the most significant 32 bits of the result, and
 // adds the accumulate value |acc|.
 V8_BASE_EXPORT int32_t SignedMulHighAndAdd32(int32_t lhs, int32_t rhs,
-                                             int32_t acc);
+        int32_t acc);
 
 // SignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
 // truncated to int32. If |rhs| is zero, then zero is returned. If |lhs|
@@ -265,10 +291,10 @@ V8_BASE_EXPORT int32_t SignedMod32(int32_t lhs, int32_t rhs);
 // returns true if the unsigned summation resulted in an overflow.
 inline bool UnsignedAddOverflow32(uint32_t lhs, uint32_t rhs, uint32_t* val) {
 #if V8_HAS_BUILTIN_SADD_OVERFLOW
-  return __builtin_uadd_overflow(lhs, rhs, val);
+    return __builtin_uadd_overflow(lhs, rhs, val);
 #else
-  *val = lhs + rhs;
-  return *val < (lhs | rhs);
+    *val = lhs + rhs;
+    return *val < (lhs | rhs);
 #endif
 }
 
@@ -276,14 +302,14 @@ inline bool UnsignedAddOverflow32(uint32_t lhs, uint32_t rhs, uint32_t* val) {
 // UnsignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
 // truncated to uint32. If |rhs| is zero, then zero is returned.
 inline uint32_t UnsignedDiv32(uint32_t lhs, uint32_t rhs) {
-  return rhs ? lhs / rhs : 0u;
+    return rhs ? lhs / rhs : 0u;
 }
 
 
 // UnsignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
 // truncated to uint32. If |rhs| is zero, then zero is returned.
 inline uint32_t UnsignedMod32(uint32_t lhs, uint32_t rhs) {
-  return rhs ? lhs % rhs : 0u;
+    return rhs ? lhs % rhs : 0u;
 }
 
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/build_config.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/build_config.h
index df0d1110a..695e67a61 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/build_config.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/build_config.h
@@ -196,9 +196,9 @@
 #endif
 
 #if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X64)
-#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK 1
+#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK true
 #else
-#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK 0
+#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK false
 #endif
 
 // Number of bits to represent the page size for paged spaces. The value of 19
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/compiler-specific.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/compiler-specific.h
index 75f89298f..8a5b9e6a6 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/compiler-specific.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/compiler-specific.h
@@ -92,4 +92,15 @@
 
 #endif  // V8_CC_MSVC
 
+// Allowing the use of noexcept by removing the keyword on older compilers that
+// do not support adding noexcept to default members.
+#if ((!defined(V8_CC_GNU) && !defined(V8_TARGET_ARCH_MIPS) &&        \
+      !defined(V8_TARGET_ARCH_MIPS64) && !defined(V8_TARGET_ARCH_PPC) && \
+      !defined(V8_TARGET_ARCH_PPC64)) ||                                 \
+     (defined(__clang__) && __cplusplus > 201300L))
+#define V8_NOEXCEPT noexcept
+#else
+#define V8_NOEXCEPT
+#endif
+
 #endif  // V8_BASE_COMPILER_SPECIFIC_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/logging.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/logging.h
index 402645f45..51a64c65b 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/logging.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/logging.h
@@ -49,7 +49,7 @@ V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
     if (V8_UNLIKELY(!(condition))) {       \
       FATAL("Check failed: %s.", message); \
     }                                      \
-  } while (0)
+  } while (false)
 #define CHECK(condition) CHECK_WITH_MSG(condition, #condition)
 
 #ifdef DEBUG
@@ -59,7 +59,7 @@ V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
     if (V8_UNLIKELY(!(condition))) {          \
       V8_Dcheck(__FILE__, __LINE__, message); \
     }                                         \
-  } while (0)
+  } while (false)
 #define DCHECK(condition) DCHECK_WITH_MSG(condition, #condition)
 
 // Helper macro for binary operators.
@@ -73,7 +73,7 @@ V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
       FATAL("Check failed: %s.", _msg->c_str());                          \
       delete _msg;                                                        \
     }                                                                     \
-  } while (0)
+  } while (false)
 
 #define DCHECK_OP(name, op, lhs, rhs)                                     \
   do {                                                                    \
@@ -84,7 +84,7 @@ V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
       V8_Dcheck(__FILE__, __LINE__, _msg->c_str());                       \
       delete _msg;                                                        \
     }                                                                     \
-  } while (0)
+  } while (false)
 
 #else
 
@@ -98,7 +98,7 @@ V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
         typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>((lhs),  \
                                                                      (rhs)); \
     CHECK_WITH_MSG(_cmp, #lhs " " #op " " #rhs);                             \
-  } while (0)
+  } while (false)
 
 #define DCHECK_WITH_MSG(condition, msg) void(0);
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/macros.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/macros.h
index a2bb5f851..a60f7a3fc 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/macros.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/macros.h
@@ -14,6 +14,9 @@
 // No-op macro which is used to work around MSVC's funky VA_ARGS support.
 #define EXPAND(x) x
 
+// This macro does nothing. That's all.
+#define NOTHING(...)
+
 // TODO(all) Replace all uses of this macro with C++'s offsetof. To do that, we
 // have to make sure that only standard-layout types and simple field
 // designators are used.
@@ -113,6 +116,12 @@ V8_INLINE Dest bit_cast(Source const& source) {
   TypeName(const TypeName&) = delete;      \
   DISALLOW_ASSIGN(TypeName)
 
+// Explicitly declare all copy/move constructors and assignments as deleted.
+#define DISALLOW_COPY_AND_MOVE_AND_ASSIGN(TypeName) \
+  TypeName(TypeName&&) = delete;                    \
+  TypeName& operator=(TypeName&&) = delete;         \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+
 // Explicitly declare all implicit constructors as deleted, namely the
 // default constructor, copy constructor and operator= functions.
 // This is especially useful for classes containing only static methods.
@@ -128,9 +137,9 @@ V8_INLINE Dest bit_cast(Source const& source) {
 
 // Disallow copying a type, and only provide move construction and move
 // assignment. Especially useful for move-only structs.
-#define MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(TypeName) \
-  TypeName(TypeName&&) = default;                  \
-  TypeName& operator=(TypeName&&) = default;       \
+#define MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(TypeName)       \
+  TypeName(TypeName&&) V8_NOEXCEPT = default;            \
+  TypeName& operator=(TypeName&&) V8_NOEXCEPT = default; \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
 
 // A macro to disallow the dynamic allocation.
@@ -189,8 +198,9 @@ V8_INLINE Dest bit_cast(Source const& source) {
 #define V8_IMMEDIATE_CRASH() ((void(*)())0)()
 #endif
 
-
-// TODO(all) Replace all uses of this macro with static_assert, remove macro.
+// A convenience wrapper around static_assert without a string message argument.
+// Once C++17 becomes the default, this macro can be removed in favor of the
+// new static_assert(condition) overload.
 #define STATIC_ASSERT(test) static_assert(test, #test)
 
 namespace v8 {
@@ -270,6 +280,12 @@ struct Use {
     (void)unused_tmp_array_for_use_macro;                          \
   } while (false)
 
+// Evaluate the instantiations of an expression with parameter packs.
+// Since USE has left-to-right evaluation order of it's arguments,
+// the parameter pack is iterated from left to right and side effects
+// have defined behavior.
+#define ITERATE_PACK(...) USE(0, ((__VA_ARGS__), 0)...)
+
 }  // namespace base
 }  // namespace v8
 
@@ -340,47 +356,37 @@ V8_INLINE A implicit_cast(A x) {
 //      write V8_2PART_UINT64_C(0x12345678,90123456);
 #define V8_2PART_UINT64_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
 
-
-// Compute the 0-relative offset of some absolute value x of type T.
-// This allows conversion of Addresses and integral types into
-// 0-relative int offsets.
-template <typename T>
-constexpr inline intptr_t OffsetFrom(T x) {
-    return x - static_cast<T>(0);
-}
-
-
-// Compute the absolute value of type T for some 0-relative offset x.
-// This allows conversion of 0-relative int offsets into Addresses and
-// integral types.
-template <typename T>
-constexpr inline T AddressFrom(intptr_t x) {
-    return static_cast<T>(static_cast<T>(0) + x);
-}
-
-
 // Return the largest multiple of m which is <= x.
 template <typename T>
 inline T RoundDown(T x, intptr_t m) {
+    STATIC_ASSERT(std::is_integral<T>::value);
     // m must be a power of two.
     DCHECK(m != 0 && ((m & (m - 1)) == 0));
-    return AddressFrom<T>(OffsetFrom(x) & -m);
+    return x & -m;
 }
 template <intptr_t m, typename T>
 constexpr inline T RoundDown(T x) {
+    STATIC_ASSERT(std::is_integral<T>::value);
     // m must be a power of two.
     STATIC_ASSERT(m != 0 && ((m & (m - 1)) == 0));
-    return AddressFrom<T>(OffsetFrom(x) & -m);
+    return x & -m;
 }
 
 // Return the smallest multiple of m which is >= x.
 template <typename T>
 inline T RoundUp(T x, intptr_t m) {
+    STATIC_ASSERT(std::is_integral<T>::value);
     return RoundDown<T>(static_cast<T>(x + m - 1), m);
 }
 template <intptr_t m, typename T>
 constexpr inline T RoundUp(T x) {
-    return RoundDown<m, T>(static_cast<T>(x + m - 1));
+    STATIC_ASSERT(std::is_integral<T>::value);
+    return RoundDown<m, T>(static_cast<T>(x + (m - 1)));
+}
+
+template <typename T, typename U>
+inline bool IsAligned(T value, U alignment) {
+    return (value & (alignment - 1)) == 0;
 }
 
 inline void* AlignedAddress(void* address, size_t alignment) {
@@ -410,4 +416,30 @@ bool is_inbounds(float_t v) {
            (kUpperBoundIsMax ? (v <= kUpperBound) : (v < kUpperBound));
 }
 
+#ifdef V8_OS_WIN
+
+// Setup for Windows shared library export.
+#ifdef BUILDING_V8_SHARED
+#define V8_EXPORT_PRIVATE __declspec(dllexport)
+#elif USING_V8_SHARED
+#define V8_EXPORT_PRIVATE __declspec(dllimport)
+#else
+#define V8_EXPORT_PRIVATE
+#endif  // BUILDING_V8_SHARED
+
+#else  // V8_OS_WIN
+
+// Setup for Linux shared library export.
+#if V8_HAS_ATTRIBUTE_VISIBILITY
+#ifdef BUILDING_V8_SHARED
+#define V8_EXPORT_PRIVATE __attribute__((visibility("default")))
+#else
+#define V8_EXPORT_PRIVATE
+#endif
+#else
+#define V8_EXPORT_PRIVATE
+#endif
+
+#endif  // V8_OS_WIN
+
 #endif  // V8_BASE_MACROS_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/platform.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/platform.h
index e4b7eeb7e..82a50d5b5 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/platform.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/platform.h
@@ -188,7 +188,7 @@ class V8_BASE_EXPORT OS {
 
         class V8_BASE_EXPORT MemoryMappedFile {
             public:
-                virtual ~MemoryMappedFile() {}
+                virtual ~MemoryMappedFile() = default;
                 virtual void* memory() const = 0;
                 virtual size_t size() const = 0;
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/time.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/time.h
index 91a2f4534..5a817a9e4 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/time.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/platform/time.h
@@ -107,10 +107,7 @@ class V8_BASE_EXPORT TimeDelta final {
         static TimeDelta FromTimespec(struct timespec ts);
         struct timespec ToTimespec() const;
 
-        TimeDelta& operator=(const TimeDelta& other) {
-            delta_ = other.delta_;
-            return *this;
-        }
+        TimeDelta& operator=(const TimeDelta& other) = default;
 
         // Computations with other deltas.
         TimeDelta operator+(const TimeDelta& other) const {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/safe_math.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/safe_math.h
index 62a2f723f..539de8ed6 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/safe_math.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/safe_math.h
@@ -46,146 +46,156 @@ namespace internal {
 //     Do stuff...
 template <typename T>
 class CheckedNumeric {
- public:
-  typedef T type;
-
-  CheckedNumeric() {}
-
-  // Copy constructor.
-  template <typename Src>
-  CheckedNumeric(const CheckedNumeric<Src>& rhs)
-      : state_(rhs.ValueUnsafe(), rhs.validity()) {}
-
-  template <typename Src>
-  CheckedNumeric(Src value, RangeConstraint validity)
-      : state_(value, validity) {}
-
-  // This is not an explicit constructor because we implicitly upgrade regular
-  // numerics to CheckedNumerics to make them easier to use.
-  template <typename Src>
-  CheckedNumeric(Src value)  // NOLINT
-      : state_(value) {
-    // Argument must be numeric.
-    STATIC_ASSERT(std::numeric_limits<Src>::is_specialized);
-  }
-
-  // IsValid() is the public API to test if a CheckedNumeric is currently valid.
-  bool IsValid() const { return validity() == RANGE_VALID; }
-
-  // ValueOrDie() The primary accessor for the underlying value. If the current
-  // state is not valid it will CHECK and crash.
-  T ValueOrDie() const {
-    CHECK(IsValid());
-    return state_.value();
-  }
-
-  // ValueOrDefault(T default_value) A convenience method that returns the
-  // current value if the state is valid, and the supplied default_value for
-  // any other state.
-  T ValueOrDefault(T default_value) const {
-    return IsValid() ? state_.value() : default_value;
-  }
-
-  // ValueFloating() - Since floating point values include their validity state,
-  // we provide an easy method for extracting them directly, without a risk of
-  // crashing on a CHECK.
-  T ValueFloating() const {
-    // Argument must be a floating-point value.
-    STATIC_ASSERT(std::numeric_limits<T>::is_iec559);
-    return CheckedNumeric<T>::cast(*this).ValueUnsafe();
-  }
-
-  // validity() - DO NOT USE THIS IN EXTERNAL CODE - It is public right now for
-  // tests and to avoid a big matrix of friend operator overloads. But the
-  // values it returns are likely to change in the future.
-  // Returns: current validity state (i.e. valid, overflow, underflow, nan).
-  // TODO(jschuh): crbug.com/332611 Figure out and implement semantics for
-  // saturation/wrapping so we can expose this state consistently and implement
-  // saturated arithmetic.
-  RangeConstraint validity() const { return state_.validity(); }
-
-  // ValueUnsafe() - DO NOT USE THIS IN EXTERNAL CODE - It is public right now
-  // for tests and to avoid a big matrix of friend operator overloads. But the
-  // values it returns are likely to change in the future.
-  // Returns: the raw numeric value, regardless of the current state.
-  // TODO(jschuh): crbug.com/332611 Figure out and implement semantics for
-  // saturation/wrapping so we can expose this state consistently and implement
-  // saturated arithmetic.
-  T ValueUnsafe() const { return state_.value(); }
-
-  // Prototypes for the supported arithmetic operator overloads.
-  template <typename Src> CheckedNumeric& operator+=(Src rhs);
-  template <typename Src> CheckedNumeric& operator-=(Src rhs);
-  template <typename Src> CheckedNumeric& operator*=(Src rhs);
-  template <typename Src> CheckedNumeric& operator/=(Src rhs);
-  template <typename Src> CheckedNumeric& operator%=(Src rhs);
-
-  CheckedNumeric operator-() const {
-    RangeConstraint validity;
-    T value = CheckedNeg(state_.value(), &validity);
-    // Negation is always valid for floating point.
-    if (std::numeric_limits<T>::is_iec559)
-      return CheckedNumeric<T>(value);
-
-    validity = GetRangeConstraint(state_.validity() | validity);
-    return CheckedNumeric<T>(value, validity);
-  }
-
-  CheckedNumeric Abs() const {
-    RangeConstraint validity;
-    T value = CheckedAbs(state_.value(), &validity);
-    // Absolute value is always valid for floating point.
-    if (std::numeric_limits<T>::is_iec559)
-      return CheckedNumeric<T>(value);
-
-    validity = GetRangeConstraint(state_.validity() | validity);
-    return CheckedNumeric<T>(value, validity);
-  }
-
-  CheckedNumeric& operator++() {
-    *this += 1;
-    return *this;
-  }
-
-  CheckedNumeric operator++(int) {
-    CheckedNumeric value = *this;
-    *this += 1;
-    return value;
-  }
-
-  CheckedNumeric& operator--() {
-    *this -= 1;
-    return *this;
-  }
-
-  CheckedNumeric operator--(int) {
-    CheckedNumeric value = *this;
-    *this -= 1;
-    return value;
-  }
-
-  // These static methods behave like a convenience cast operator targeting
-  // the desired CheckedNumeric type. As an optimization, a reference is
-  // returned when Src is the same type as T.
-  template <typename Src>
-  static CheckedNumeric<T> cast(
-      Src u,
-      typename enable_if<std::numeric_limits<Src>::is_specialized, int>::type =
-          0) {
-    return u;
-  }
-
-  template <typename Src>
-  static CheckedNumeric<T> cast(
-      const CheckedNumeric<Src>& u,
-      typename enable_if<!is_same<Src, T>::value, int>::type = 0) {
-    return u;
-  }
-
-  static const CheckedNumeric<T>& cast(const CheckedNumeric<T>& u) { return u; }
-
- private:
-  CheckedNumericState<T> state_;
+    public:
+        typedef T type;
+
+        CheckedNumeric() = default;
+
+        // Copy constructor.
+        template <typename Src>
+        CheckedNumeric(const CheckedNumeric<Src>& rhs)
+            : state_(rhs.ValueUnsafe(), rhs.validity()) {}
+
+        template <typename Src>
+        CheckedNumeric(Src value, RangeConstraint validity)
+            : state_(value, validity) {}
+
+        // This is not an explicit constructor because we implicitly upgrade regular
+        // numerics to CheckedNumerics to make them easier to use.
+        template <typename Src>
+        CheckedNumeric(Src value)  // NOLINT
+            : state_(value) {
+            // Argument must be numeric.
+            STATIC_ASSERT(std::numeric_limits<Src>::is_specialized);
+        }
+
+        // IsValid() is the public API to test if a CheckedNumeric is currently valid.
+        bool IsValid() const {
+            return validity() == RANGE_VALID;
+        }
+
+        // ValueOrDie() The primary accessor for the underlying value. If the current
+        // state is not valid it will CHECK and crash.
+        T ValueOrDie() const {
+            CHECK(IsValid());
+            return state_.value();
+        }
+
+        // ValueOrDefault(T default_value) A convenience method that returns the
+        // current value if the state is valid, and the supplied default_value for
+        // any other state.
+        T ValueOrDefault(T default_value) const {
+            return IsValid() ? state_.value() : default_value;
+        }
+
+        // ValueFloating() - Since floating point values include their validity state,
+        // we provide an easy method for extracting them directly, without a risk of
+        // crashing on a CHECK.
+        T ValueFloating() const {
+            // Argument must be a floating-point value.
+            STATIC_ASSERT(std::numeric_limits<T>::is_iec559);
+            return CheckedNumeric<T>::cast(*this).ValueUnsafe();
+        }
+
+        // validity() - DO NOT USE THIS IN EXTERNAL CODE - It is public right now for
+        // tests and to avoid a big matrix of friend operator overloads. But the
+        // values it returns are likely to change in the future.
+        // Returns: current validity state (i.e. valid, overflow, underflow, nan).
+        // TODO(jschuh): crbug.com/332611 Figure out and implement semantics for
+        // saturation/wrapping so we can expose this state consistently and implement
+        // saturated arithmetic.
+        RangeConstraint validity() const {
+            return state_.validity();
+        }
+
+        // ValueUnsafe() - DO NOT USE THIS IN EXTERNAL CODE - It is public right now
+        // for tests and to avoid a big matrix of friend operator overloads. But the
+        // values it returns are likely to change in the future.
+        // Returns: the raw numeric value, regardless of the current state.
+        // TODO(jschuh): crbug.com/332611 Figure out and implement semantics for
+        // saturation/wrapping so we can expose this state consistently and implement
+        // saturated arithmetic.
+        T ValueUnsafe() const {
+            return state_.value();
+        }
+
+        // Prototypes for the supported arithmetic operator overloads.
+        template <typename Src> CheckedNumeric& operator+=(Src rhs);
+        template <typename Src> CheckedNumeric& operator-=(Src rhs);
+        template <typename Src> CheckedNumeric& operator*=(Src rhs);
+        template <typename Src> CheckedNumeric& operator/=(Src rhs);
+        template <typename Src> CheckedNumeric& operator%=(Src rhs);
+
+        CheckedNumeric operator-() const {
+            RangeConstraint validity;
+            T value = CheckedNeg(state_.value(), &validity);
+            // Negation is always valid for floating point.
+            if (std::numeric_limits<T>::is_iec559) {
+                return CheckedNumeric<T>(value);
+            }
+
+            validity = GetRangeConstraint(state_.validity() | validity);
+            return CheckedNumeric<T>(value, validity);
+        }
+
+        CheckedNumeric Abs() const {
+            RangeConstraint validity;
+            T value = CheckedAbs(state_.value(), &validity);
+            // Absolute value is always valid for floating point.
+            if (std::numeric_limits<T>::is_iec559) {
+                return CheckedNumeric<T>(value);
+            }
+
+            validity = GetRangeConstraint(state_.validity() | validity);
+            return CheckedNumeric<T>(value, validity);
+        }
+
+        CheckedNumeric& operator++() {
+            *this += 1;
+            return *this;
+        }
+
+        CheckedNumeric operator++(int) {
+            CheckedNumeric value = *this;
+            *this += 1;
+            return value;
+        }
+
+        CheckedNumeric& operator--() {
+            *this -= 1;
+            return *this;
+        }
+
+        CheckedNumeric operator--(int) {
+            CheckedNumeric value = *this;
+            *this -= 1;
+            return value;
+        }
+
+        // These static methods behave like a convenience cast operator targeting
+        // the desired CheckedNumeric type. As an optimization, a reference is
+        // returned when Src is the same type as T.
+        template <typename Src>
+        static CheckedNumeric<T> cast(
+            Src u,
+            typename enable_if<std::numeric_limits<Src>::is_specialized, int>::type =
+                0) {
+            return u;
+        }
+
+        template <typename Src>
+        static CheckedNumeric<T> cast(
+            const CheckedNumeric<Src>& u,
+            typename enable_if<!is_same<Src, T>::value, int>::type = 0) {
+            return u;
+        }
+
+        static const CheckedNumeric<T>& cast(const CheckedNumeric<T>& u) {
+            return u;
+        }
+
+    private:
+        CheckedNumericState<T> state_;
 };
 
 // This is the boilerplate for the standard arithmetic operator overloads. A
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/base/template-utils.h b/test-app/runtime/src/main/cpp/v8_inspector/src/base/template-utils.h
index 7e0c29149..5267d5318 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/base/template-utils.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/base/template-utils.h
@@ -114,6 +114,16 @@ typename detail::fold_helper<Func, Ts...>::result_t {
     std::forward<Ts>(more)...);
 }
 
+// {is_same<Ts...>::value} is true if all Ts are the same, false otherwise.
+template <typename... Ts>
+struct is_same : public std::false_type {};
+template <>
+struct is_same<> : public std::true_type {};
+template <typename T>
+struct is_same<T> : public std::true_type {};
+template <typename T, typename... Ts>
+struct is_same<T, T, Ts...> : public is_same<T, Ts...> {};
+
 }  // namespace base
 }  // namespace v8
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/checks.h b/test-app/runtime/src/main/cpp/v8_inspector/src/checks.h
index 8eb10f43d..4a0afa4f5 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/checks.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/checks.h
@@ -5,7 +5,7 @@
 #ifndef V8_CHECKS_H_
 #define V8_CHECKS_H_
 
-#include "include/v8.h"
+#include "include/v8-internal.h"
 #include "src/base/logging.h"
 #include "src/globals.h"
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/debug/debug-interface.h b/test-app/runtime/src/main/cpp/v8_inspector/src/debug/debug-interface.h
index 71713bf75..bc88e45a1 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/debug/debug-interface.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/debug/debug-interface.h
@@ -154,9 +154,11 @@ void GetLoadedScripts(Isolate* isolate, PersistentValueVector<Script>& scripts);
 MaybeLocal<UnboundScript> CompileInspectorScript(Isolate* isolate,
         Local<String> source);
 
+enum ExceptionType { kException, kPromiseRejection };
+
 class DebugDelegate {
     public:
-        virtual ~DebugDelegate() {}
+        virtual ~DebugDelegate() = default;
         virtual void ScriptCompiled(v8::Local<Script> script, bool is_live_edited,
                                     bool has_compile_error) {}
         // |inspector_break_points_hit| contains id of breakpoints installed with
@@ -166,8 +168,8 @@ class DebugDelegate {
             const std::vector<debug::BreakpointId>& inspector_break_points_hit) {}
         virtual void ExceptionThrown(v8::Local<v8::Context> paused_context,
                                      v8::Local<v8::Value> exception,
-                                     v8::Local<v8::Value> promise, bool is_uncaught) {
-        }
+                                     v8::Local<v8::Value> promise, bool is_uncaught,
+                                     ExceptionType exception_type) {}
         virtual bool IsFunctionBlackboxed(v8::Local<debug::Script> script,
                                           const debug::Location& start,
                                           const debug::Location& end) {
@@ -179,7 +181,7 @@ void SetDebugDelegate(Isolate* isolate, DebugDelegate* listener);
 
 class AsyncEventDelegate {
     public:
-        virtual ~AsyncEventDelegate() {}
+        virtual ~AsyncEventDelegate() = default;
         virtual void AsyncEventOccurred(debug::DebugAsyncActionType type, int id,
                                         bool is_blackboxed) = 0;
 };
@@ -504,6 +506,20 @@ class PostponeInterruptsScope {
         std::unique_ptr<i::PostponeInterruptsScope> scope_;
 };
 
+class WeakMap : public v8::Object {
+    public:
+        V8_WARN_UNUSED_RESULT v8::MaybeLocal<v8::Value> Get(
+            v8::Local<v8::Context> context, v8::Local<v8::Value> key);
+        V8_WARN_UNUSED_RESULT v8::MaybeLocal<WeakMap> Set(
+            v8::Local<v8::Context> context, v8::Local<v8::Value> key,
+            v8::Local<v8::Value> value);
+
+        static Local<WeakMap> New(v8::Isolate* isolate);
+        V8_INLINE static WeakMap* Cast(Value* obj);
+
+    private:
+        WeakMap();
+};
 }  // namespace debug
 }  // namespace v8
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/debug/interface-types.h b/test-app/runtime/src/main/cpp/v8_inspector/src/debug/interface-types.h
index f31eab0b1..113b05269 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/debug/interface-types.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/debug/interface-types.h
@@ -60,7 +60,7 @@ struct WasmDisassemblyOffsetTableEntry {
 
 struct WasmDisassembly {
     using OffsetTable = std::vector<WasmDisassemblyOffsetTableEntry>;
-    WasmDisassembly() {}
+    WasmDisassembly() = default;
     WasmDisassembly(std::string disassembly, OffsetTable offset_table)
         : disassembly(std::move(disassembly)),
           offset_table(std::move(offset_table)) {}
@@ -169,6 +169,8 @@ class ConsoleDelegate {
                                 const ConsoleContext& context) {}
         virtual void Time(const ConsoleCallArguments& args,
                           const ConsoleContext& context) {}
+        virtual void TimeLog(const ConsoleCallArguments& args,
+                             const ConsoleContext& context) {}
         virtual void TimeEnd(const ConsoleCallArguments& args,
                              const ConsoleContext& context) {}
         virtual void TimeStamp(const ConsoleCallArguments& args,
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/flag-definitions.h b/test-app/runtime/src/main/cpp/v8_inspector/src/flag-definitions.h
index 4f8912199..5a35b6590 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/flag-definitions.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/flag-definitions.h
@@ -211,17 +211,18 @@ DEFINE_IMPLICATION(harmony_class_fields, harmony_private_fields)
 // Update bootstrapper.cc whenever adding a new feature flag.
 
 // Features that are still work in progress (behind individual flags).
-#define HARMONY_INPROGRESS_BASE(V)                                    \
-  V(harmony_do_expressions, "harmony do-expressions")                 \
-  V(harmony_class_fields, "harmony fields in class literals")         \
-  V(harmony_static_fields, "harmony static fields in class literals") \
-  V(harmony_await_optimization, "harmony await taking 1 tick")
+#define HARMONY_INPROGRESS_BASE(V)                             \
+  V(harmony_do_expressions, "harmony do-expressions")          \
+  V(harmony_class_fields, "harmony fields in class literals")  \
+  V(harmony_await_optimization, "harmony await taking 1 tick") \
+  V(harmony_regexp_sequence, "RegExp Unicode sequence properties")
 
 #ifdef V8_INTL_SUPPORT
-#define HARMONY_INPROGRESS(V)      \
-  HARMONY_INPROGRESS_BASE(V)       \
-  V(harmony_locale, "Intl.Locale") \
-  V(harmony_intl_relative_time_format, "Intl.RelativeTimeFormat")
+#define HARMONY_INPROGRESS(V)                    \
+  HARMONY_INPROGRESS_BASE(V)                     \
+  V(harmony_locale, "Intl.Locale")               \
+  V(harmony_intl_list_format, "Intl.ListFormat") \
+  V(harmony_intl_segmenter, "Intl.Segmenter")
 #else
 #define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
 #endif
@@ -232,18 +233,26 @@ DEFINE_IMPLICATION(harmony_class_fields, harmony_private_fields)
   V(harmony_private_fields, "harmony private fields in class literals")    \
   V(harmony_numeric_separator, "harmony numeric separator between digits") \
   V(harmony_string_matchall, "harmony String.prototype.matchAll")          \
-  V(harmony_symbol_description, "harmony Symbol.prototype.description")
+  V(harmony_static_fields, "harmony static fields in class literals")      \
+  V(harmony_json_stringify, "Well-formed JSON.stringify")
 
 // Features that are shipping (turned on by default, but internal flag remains).
-#define HARMONY_SHIPPING(V)                                                   \
-  V(harmony_string_trimming, "harmony String.prototype.trim{Start,End}")      \
-  V(harmony_sharedarraybuffer, "harmony sharedarraybuffer")                   \
-  V(harmony_function_tostring, "harmony Function.prototype.toString")         \
-  V(harmony_import_meta, "harmony import.meta property")                      \
-  V(harmony_bigint, "harmony arbitrary precision integers")                   \
-  V(harmony_dynamic_import, "harmony dynamic import")                         \
-  V(harmony_array_prototype_values, "harmony Array.prototype.values")         \
-  V(harmony_array_flat, "harmony Array.prototype.{flat,flatMap}")
+#define HARMONY_SHIPPING_BASE(V)                                         \
+  V(harmony_sharedarraybuffer, "harmony sharedarraybuffer")              \
+  V(harmony_import_meta, "harmony import.meta property")                 \
+  V(harmony_dynamic_import, "harmony dynamic import")                    \
+  V(harmony_array_prototype_values, "harmony Array.prototype.values")    \
+  V(harmony_array_flat, "harmony Array.prototype.{flat,flatMap}")        \
+  V(harmony_symbol_description, "harmony Symbol.prototype.description")  \
+  V(harmony_global, "harmony global")
+
+#ifdef V8_INTL_SUPPORT
+#define HARMONY_SHIPPING(V) \
+  HARMONY_SHIPPING_BASE(V)  \
+  V(harmony_intl_relative_time_format, "Intl.RelativeTimeFormat")
+#else
+#define HARMONY_SHIPPING(V) HARMONY_SHIPPING_BASE(V)
+#endif
 
 // Once a shipping feature has proved stable in the wild, it will be dropped
 // from HARMONY_SHIPPING, all occurrences of the FLAG_ variable are removed,
@@ -316,6 +325,11 @@ DEFINE_BOOL(optimize_for_size, false,
             "Enables optimizations which favor memory size over execution "
             "speed")
 
+// Flag for one shot optimiztions.
+DEFINE_BOOL(enable_one_shot_optimization, true,
+            "Enable size optimizations for the code that will "
+            "only be executed once")
+
 DEFINE_VALUE_IMPLICATION(optimize_for_size, max_semi_space_size, 1)
 
 // Flags for data representation optimizations
@@ -382,6 +396,11 @@ DEFINE_INT(concurrent_recompilation_delay, 0,
            "artificial compilation delay in ms")
 DEFINE_BOOL(block_concurrent_recompilation, false,
             "block queued jobs until released")
+DEFINE_BOOL(concurrent_compiler_frontend, false,
+            "run optimizing compiler's frontend phases on a separate thread")
+DEFINE_IMPLICATION(future, concurrent_compiler_frontend)
+DEFINE_BOOL(strict_heap_broker, false, "fail on incomplete serialization")
+DEFINE_BOOL(trace_heap_broker, false, "trace the heap broker")
 
 // Flags for stress-testing the compiler.
 DEFINE_INT(stress_runs, 0, "number of stress runs")
@@ -431,6 +450,8 @@ DEFINE_BOOL(trace_verify_csa, false, "trace code stubs verification")
 DEFINE_STRING(csa_trap_on_node, nullptr,
               "trigger break point when a node with given id is created in "
               "given stub. The format is: StubName,NodeId")
+DEFINE_BOOL_READONLY(fixed_array_bounds_checks, DEBUG_BOOL,
+                     "enable FixedArray bounds checks")
 DEFINE_BOOL(turbo_stats, false, "print TurboFan statistics")
 DEFINE_BOOL(turbo_stats_nvp, false,
             "print TurboFan statistics in machine-readable format")
@@ -506,9 +527,6 @@ DEFINE_BOOL(untrusted_code_mitigations, V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS,
             "Enable mitigations for executing untrusted code")
 #undef V8_DEFAULT_UNTRUSTED_CODE_MITIGATIONS
 
-DEFINE_BOOL(branch_load_poisoning, false, "Mask loads with branch conditions.")
-DEFINE_IMPLICATION(future, branch_load_poisoning)
-
 // Flags to help platform porters
 DEFINE_BOOL(minimal, false,
             "simplifies execution model to make porting "
@@ -524,18 +542,18 @@ DEFINE_BOOL(wasm_disable_structured_cloning, false,
             "disable wasm structured cloning")
 DEFINE_INT(wasm_num_compilation_tasks, 10,
            "number of parallel compilation tasks for wasm")
-DEFINE_DEBUG_BOOL(wasm_trace_native_heap, false,
+DEFINE_DEBUG_BOOL(trace_wasm_native_heap, false,
                   "trace wasm native heap events")
 DEFINE_BOOL(wasm_write_protect_code_memory, false,
             "write protect code memory on the wasm native heap")
-DEFINE_BOOL(wasm_trace_serialization, false,
+DEFINE_BOOL(trace_wasm_serialization, false,
             "trace serialization/deserialization")
 DEFINE_BOOL(wasm_async_compilation, true,
             "enable actual asynchronous compilation for WebAssembly.compile")
 DEFINE_BOOL(wasm_test_streaming, false,
             "use streaming compilation instead of async compilation for tests")
 DEFINE_UINT(wasm_max_mem_pages, v8::internal::wasm::kV8MaxWasmMemoryPages,
-            "maximum memory size of a wasm instance")
+            "maximum number of 64KiB memory pages of a wasm instance")
 DEFINE_UINT(wasm_max_table_size, v8::internal::wasm::kV8MaxWasmTableSize,
             "maximum table size of a wasm instance")
 // Enable Liftoff by default on ia32 and x64. More architectures will follow
@@ -568,7 +586,7 @@ DEFINE_DEBUG_BOOL(trace_liftoff, false,
                   "trace Liftoff, the baseline compiler for WebAssembly")
 DEFINE_DEBUG_BOOL(wasm_break_on_decoder_error, false,
                   "debug break when wasm decoder encounters an error")
-DEFINE_BOOL(wasm_trace_memory, false,
+DEFINE_BOOL(trace_wasm_memory, false,
             "print all memory updates performed in wasm code")
 // Fuzzers use {wasm_tier_mask_for_testing} together with {liftoff} and
 // {no_wasm_tier_up} to force some functions to be compiled with Turbofan.
@@ -588,22 +606,18 @@ DEFINE_DEBUG_BOOL(dump_wasm_module, false, "dump wasm module bytes")
 DEFINE_STRING(dump_wasm_module_path, nullptr,
               "directory to dump wasm modules to")
 
-DEFINE_BOOL(experimental_wasm_simd, false,
-            "enable prototype simd opcodes for wasm")
-DEFINE_BOOL(experimental_wasm_eh, false,
-            "enable prototype exception handling opcodes for wasm")
-DEFINE_BOOL(experimental_wasm_mv, false,
-            "enable prototype multi-value support for wasm")
-DEFINE_BOOL(experimental_wasm_threads, false,
-            "enable prototype threads for wasm")
-DEFINE_BOOL(experimental_wasm_sat_f2i_conversions, false,
-            "enable non-trapping float-to-int conversions for wasm")
-DEFINE_BOOL(experimental_wasm_se, true,
-            "enable prototype sign extension opcodes for wasm")
-DEFINE_BOOL(experimental_wasm_anyref, false,
-            "enable prototype anyref support for wasm")
-DEFINE_BOOL(experimental_wasm_mut_global, true,
-            "enable prototype import/export mutable global support for wasm")
+// Declare command-line flags for WASM features. Warning: avoid using these
+// flags directly in the implementation. Instead accept wasm::WasmFeatures
+// for configurability.
+#include "src/wasm/wasm-feature-flags.h"
+
+#define SPACE
+#define DECL_WASM_FLAG(feat, desc, val)      \
+  DEFINE_BOOL(experimental_wasm_##feat, val, \
+              "enable prototype " desc " for wasm")
+FOREACH_WASM_FEATURE_FLAG(DECL_WASM_FLAG, SPACE)
+#undef DECL_WASM_FLAG
+#undef SPACE
 
 DEFINE_BOOL(wasm_opt, false, "enable wasm optimization")
 DEFINE_BOOL(wasm_no_bounds_checks, false,
@@ -611,6 +625,12 @@ DEFINE_BOOL(wasm_no_bounds_checks, false,
 DEFINE_BOOL(wasm_no_stack_checks, false,
             "disable stack checks (performance testing only)")
 
+DEFINE_BOOL(wasm_shared_engine, true,
+            "shares one wasm engine between all isolates within a process")
+DEFINE_IMPLICATION(future, wasm_shared_engine)
+DEFINE_BOOL(wasm_shared_code, true,
+            "shares code underlying a wasm module when it is transferred")
+DEFINE_IMPLICATION(future, wasm_shared_code)
 DEFINE_BOOL(wasm_trap_handler, true,
             "use signal handlers to catch out of bounds memory access in wasm"
             " (currently Linux x86_64 only)")
@@ -823,11 +843,11 @@ DEFINE_BOOL(enable_popcnt, true,
 DEFINE_STRING(arm_arch, ARM_ARCH_DEFAULT,
               "generate instructions for the selected ARM architecture if "
               "available: armv6, armv7, armv7+sudiv or armv8")
-DEFINE_BOOL(enable_vldr_imm, false,
-            "enable use of constant pools for double immediate (ARM only)")
 DEFINE_BOOL(force_long_branches, false,
             "force all emitted branches to be in long mode (MIPS/PPC only)")
 DEFINE_STRING(mcpu, "auto", "enable optimization for specific cpu")
+DEFINE_BOOL(partial_constant_pool, true,
+            "enable use of partial constant pools (X64 only)")
 
 // Deprecated ARM flags (replaced by arm_arch).
 DEFINE_MAYBE_BOOL(enable_armv7, "deprecated (use --arm_arch instead)")
@@ -860,8 +880,6 @@ DEFINE_BOOL(expose_trigger_failure, false, "expose trigger-failure extension")
 DEFINE_INT(stack_trace_limit, 10, "number of stack frames to capture")
 DEFINE_BOOL(builtins_in_stack_traces, false,
             "show built-in functions in stack traces")
-DEFINE_BOOL(enable_experimental_builtins, false,
-            "enable new csa-based experimental builtins")
 DEFINE_BOOL(disallow_code_generation_from_strings, false,
             "disallow eval and friends")
 DEFINE_BOOL(expose_async_hooks, false, "expose async_hooks object")
@@ -908,11 +926,6 @@ DEFINE_BOOL(compiler_dispatcher, false, "enable compiler dispatcher")
 DEFINE_BOOL(trace_compiler_dispatcher, false,
             "trace compiler dispatcher activity")
 
-// compiler-dispatcher-job.cc
-DEFINE_BOOL(
-    trace_compiler_dispatcher_jobs, false,
-    "trace progress of individual jobs managed by the compiler dispatcher")
-
 // cpu-profiler.cc
 DEFINE_INT(cpu_profiler_sampling_interval, 1000,
            "CPU profiler sampling interval in microseconds")
@@ -965,7 +978,6 @@ DEFINE_INT(heap_snapshot_string_limit, 1024,
 DEFINE_BOOL(sampling_heap_profiler_suppress_randomness, false,
             "Use constant sample intervals to eliminate test flakiness")
 
-
 // v8.cc
 DEFINE_BOOL(use_idle_notification, true,
             "Use idle notification to reduce memory footprint.")
@@ -1030,6 +1042,9 @@ DEFINE_BOOL(trace_sim_messages, false,
             "Trace simulator debug messages. Implied by --trace-sim.")
 
 // isolate.cc
+DEFINE_BOOL(async_stack_traces, false,
+            "include async stack traces in Error.stack")
+DEFINE_IMPLICATION(async_stack_traces, harmony_await_optimization)
 DEFINE_BOOL(stack_trace_on_illegal, false,
             "print stack trace when an illegal exception is thrown")
 DEFINE_BOOL(abort_on_uncaught_exception, false,
@@ -1071,12 +1086,15 @@ DEFINE_VALUE_IMPLICATION(runtime_call_stats, runtime_stats, 1)
 #endif
 DEFINE_BOOL_READONLY(embedded_builtins, V8_EMBEDDED_BUILTINS_BOOL,
                      "Embed builtin code into the binary.")
+// TODO(jgruber,v8:6666): Remove once ia32 has full embedded builtin support.
+DEFINE_BOOL_READONLY(
+    ia32_verify_root_register, false,
+    "Check that the value of the root register was not clobbered.")
+// TODO(jgruber,v8:6666): Remove once ia32 has full embedded builtin support.
+DEFINE_BOOL(print_embedded_builtin_candidates, false,
+            "Prints builtins that are not yet embedded but could be.")
 DEFINE_BOOL(lazy_deserialization, true,
             "Deserialize code lazily from the snapshot.")
-DEFINE_BOOL(lazy_handler_deserialization, true,
-            "Deserialize bytecode handlers lazily from the snapshot.")
-DEFINE_IMPLICATION(lazy_handler_deserialization, lazy_deserialization)
-DEFINE_IMPLICATION(future, lazy_handler_deserialization)
 DEFINE_BOOL(trace_lazy_deserialization, false, "Trace lazy deserialization.")
 DEFINE_BOOL(profile_deserialization, false,
             "Print the time it takes to deserialize the snapshot.")
@@ -1132,6 +1150,11 @@ DEFINE_BOOL(use_external_strings, false, "Use external strings for source code")
 DEFINE_STRING(map_counters, "", "Map counters to a file")
 DEFINE_ARGS(js_arguments,
             "Pass all remaining arguments to the script. Alias for \"--\".")
+DEFINE_BOOL(mock_arraybuffer_allocator, false,
+            "Use a mock ArrayBuffer allocator for testing.")
+DEFINE_SIZE_T(mock_arraybuffer_allocator_limit, 0,
+              "Memory limit for mock ArrayBuffer allocator used to simulate "
+              "OOM for testing.")
 
 //
 // GDB JIT integration flags.
@@ -1245,6 +1268,9 @@ DEFINE_BOOL(log_function_events, false,
 DEFINE_BOOL(prof, false,
             "Log statistical profiling information (implies --log-code).")
 
+DEFINE_BOOL(detailed_line_info, false,
+            "Always generate detailed line information for CPU profiling.")
+
 #if defined(ANDROID)
 // Phones and tablets have processors that are much slower than desktop
 // and laptop computers for which current heuristics are tuned.
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/globals.h b/test-app/runtime/src/main/cpp/v8_inspector/src/globals.h
index 371b546fe..90a492937 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/globals.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/globals.h
@@ -11,38 +11,12 @@
 #include <limits>
 #include <ostream>
 
-#include "include/v8.h"
+#include "include/v8-internal.h"
 #include "src/base/build_config.h"
 #include "src/base/flags.h"
 #include "src/base/logging.h"
 #include "src/base/macros.h"
 
-#ifdef V8_OS_WIN
-
-// Setup for Windows shared library export.
-#ifdef BUILDING_V8_SHARED
-#define V8_EXPORT_PRIVATE __declspec(dllexport)
-#elif USING_V8_SHARED
-#define V8_EXPORT_PRIVATE __declspec(dllimport)
-#else
-#define V8_EXPORT_PRIVATE
-#endif  // BUILDING_V8_SHARED
-
-#else  // V8_OS_WIN
-
-// Setup for Linux shared library export.
-#if V8_HAS_ATTRIBUTE_VISIBILITY
-#ifdef BUILDING_V8_SHARED
-#define V8_EXPORT_PRIVATE __attribute__((visibility("default")))
-#else
-#define V8_EXPORT_PRIVATE
-#endif
-#else
-#define V8_EXPORT_PRIVATE
-#endif
-
-#endif  // V8_OS_WIN
-
 #define V8_INFINITY std::numeric_limits<double>::infinity()
 
 namespace v8 {
@@ -81,9 +55,9 @@ namespace internal {
 // Determine whether the architecture uses an embedded constant pool
 // (contiguous constant pool embedded in code object).
 #if V8_TARGET_ARCH_PPC
-#define V8_EMBEDDED_CONSTANT_POOL 1
+#define V8_EMBEDDED_CONSTANT_POOL true
 #else
-#define V8_EMBEDDED_CONSTANT_POOL 0
+#define V8_EMBEDDED_CONSTANT_POOL false
 #endif
 
 #ifdef V8_TARGET_ARCH_ARM
@@ -102,14 +76,14 @@ constexpr int kStackSpaceRequiredForCompilation = 40;
 
 // Determine whether double field unboxing feature is enabled.
 #if V8_TARGET_ARCH_64_BIT
-#define V8_DOUBLE_FIELDS_UNBOXING 1
+#define V8_DOUBLE_FIELDS_UNBOXING true
 #else
-#define V8_DOUBLE_FIELDS_UNBOXING 0
+#define V8_DOUBLE_FIELDS_UNBOXING false
 #endif
 
 // Some types of tracing require the SFI to store a unique ID.
 #if defined(V8_TRACE_MAPS) || defined(V8_TRACE_IGNITION)
-#define V8_SFI_HAS_UNIQUE_ID 1
+#define V8_SFI_HAS_UNIQUE_ID true
 #endif
 
 // Superclass for classes only using static method functions.
@@ -121,10 +95,6 @@ class AllStatic {
 #endif
 };
 
-// DEPRECATED
-// TODO(leszeks): Delete this during a quiet period
-#define BASE_EMBEDDED
-
 typedef uint8_t byte;
 typedef uintptr_t Address;
 static const Address kNullAddress = 0;
@@ -183,7 +153,7 @@ constexpr int kDoubleSizeLog2 = 3;
 // ARM64 only supports direct calls within a 128 MB range.
 constexpr size_t kMaxWasmCodeMemory = 128 * MB;
 #else
-constexpr size_t kMaxWasmCodeMemory = 512 * MB;
+constexpr size_t kMaxWasmCodeMemory = 1024 * MB;
 #endif
 
 #if V8_HOST_ARCH_64_BIT
@@ -192,13 +162,7 @@ constexpr intptr_t kIntptrSignBit =
     static_cast<intptr_t>(uintptr_t{0x8000000000000000});
 constexpr uintptr_t kUintptrAllBitsSet = uintptr_t{0xFFFFFFFFFFFFFFFF};
 constexpr bool kRequiresCodeRange = true;
-#if V8_TARGET_ARCH_MIPS64
-// To use pseudo-relative jumps such as j/jal instructions which have 28-bit
-// encoded immediate, the addresses have to be in range of 256MB aligned
-// region. Used only for large object space.
-constexpr size_t kMaximalCodeRangeSize = 256 * MB;
-constexpr size_t kCodeRangeAreaAlignment = 256 * MB;
-#elif V8_HOST_ARCH_PPC && V8_TARGET_ARCH_PPC && V8_OS_LINUX
+#if V8_HOST_ARCH_PPC && V8_TARGET_ARCH_PPC && V8_OS_LINUX
 constexpr size_t kMaximalCodeRangeSize = 512 * MB;
 constexpr size_t kCodeRangeAreaAlignment = 64 * KB;  // OS page on PPC Linux
 #elif V8_TARGET_ARCH_ARM64
@@ -239,8 +203,8 @@ constexpr size_t kCodeRangeAreaAlignment = 4 * KB;  // OS page.
 constexpr size_t kReservedCodeRangePages = 0;
 #endif
 
-// Trigger an incremental GCs once the external memory reaches this limit.
-constexpr int kExternalAllocationSoftLimit = 64 * MB;
+constexpr int kExternalAllocationSoftLimit =
+    internal::Internals::kExternalAllocationSoftLimit;
 
 // Maximum object size that gets allocated into regular pages. Objects larger
 // than that size are allocated in large object space and are never moved in
@@ -365,6 +329,10 @@ inline LanguageMode stricter_language_mode(LanguageMode mode1,
                                      static_cast<int>(mode2));
 }
 
+// A non-keyed store is of the form a.x = foo or a["x"] = foo whereas
+// a keyed store is of the form a[expression] = foo.
+enum class StoreOrigin { kMaybeKeyed, kNamed };
+
 enum TypeofMode : int { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
 
 // Enums used by CEntry.
@@ -488,6 +456,9 @@ constexpr uint32_t kFreeListZapValue = 0xfeed1eaf;
 constexpr int kCodeZapValue = 0xbadc0de;
 constexpr uint32_t kPhantomReferenceZap = 0xca11bac;
 
+// Page constants.
+static const intptr_t kPageAlignmentMask = (intptr_t{1} << kPageSizeBits) - 1;
+
 // On Intel architecture, cache line size is 64 bytes.
 // On ARM it may be less (32 bytes), but as far this constant is
 // used for aligning data, it doesn't hurt to align on a greater value.
@@ -652,11 +623,13 @@ enum Movability { kMovable, kImmovable };
 
 enum VisitMode {
     VISIT_ALL,
+    VISIT_ALL_BUT_READ_ONLY,
     VISIT_ALL_IN_MINOR_MC_MARK,
     VISIT_ALL_IN_MINOR_MC_UPDATE,
     VISIT_ALL_IN_SCAVENGE,
     VISIT_ALL_IN_SWEEP_NEWSPACE,
     VISIT_ONLY_STRONG,
+    VISIT_ONLY_STRONG_FOR_SERIALIZATION,
     VISIT_FOR_SERIALIZATION,
 };
 
@@ -732,6 +705,27 @@ enum InlineCacheState {
     GENERIC,
 };
 
+// Printing support.
+inline const char* InlineCacheState2String(InlineCacheState state) {
+    switch (state) {
+    case UNINITIALIZED:
+        return "UNINITIALIZED";
+    case PREMONOMORPHIC:
+        return "PREMONOMORPHIC";
+    case MONOMORPHIC:
+        return "MONOMORPHIC";
+    case RECOMPUTE_HANDLER:
+        return "RECOMPUTE_HANDLER";
+    case POLYMORPHIC:
+        return "POLYMORPHIC";
+    case MEGAMORPHIC:
+        return "MEGAMORPHIC";
+    case GENERIC:
+        return "GENERIC";
+    }
+    UNREACHABLE();
+}
+
 enum WhereToStart { kStartAtReceiver, kStartAtPrototype };
 
 enum ResultSentinel { kNotFound = -1, kUnsupported = -2 };
@@ -953,6 +947,8 @@ enum AllocationSiteMode {
     LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
 };
 
+enum class AllocationSiteUpdateMode { kUpdate, kCheckOnly };
+
 // The mips architecture prior to revision 5 has inverted encoding for sNaN.
 #if (V8_TARGET_ARCH_MIPS && !defined(_MIPS_ARCH_MIPS32R6) &&           \
      (!defined(USE_SIMULATOR) || !defined(_MIPS_TARGET_SIMULATOR))) || \
@@ -1101,7 +1097,6 @@ enum InitializationFlag : uint8_t { kNeedsInitialization, kCreatedInitialized };
 
 enum MaybeAssignedFlag : uint8_t { kNotAssigned, kMaybeAssigned };
 
-// Serialized in PreparseData, so numeric values should not be changed.
 enum ParseErrorType { kSyntaxError = 0, kReferenceError = 1 };
 
 enum FunctionKind : uint8_t {
@@ -1561,7 +1556,7 @@ V8_INLINE static bool HasWeakHeapObjectTag(const Object* value) {
             kWeakHeapObjectTag);
 }
 
-V8_INLINE static bool IsClearedWeakHeapObject(MaybeObject* value) {
+V8_INLINE static bool IsClearedWeakHeapObject(const MaybeObject* value) {
     return reinterpret_cast<intptr_t>(value) == kClearedWeakHeapObject;
 }
 
@@ -1604,6 +1599,7 @@ enum class LoadSensitivity {
 #define FOREACH_WASM_TRAPREASON(V) \
   V(TrapUnreachable)               \
   V(TrapMemOutOfBounds)            \
+  V(TrapUnalignedAccess)           \
   V(TrapDivByZero)                 \
   V(TrapDivUnrepresentable)        \
   V(TrapRemByZero)                 \
@@ -1611,6 +1607,65 @@ enum class LoadSensitivity {
   V(TrapFuncInvalid)               \
   V(TrapFuncSigMismatch)
 
+enum KeyedAccessLoadMode {
+    STANDARD_LOAD,
+    LOAD_IGNORE_OUT_OF_BOUNDS,
+};
+
+enum KeyedAccessStoreMode {
+    STANDARD_STORE,
+    STORE_TRANSITION_TO_OBJECT,
+    STORE_TRANSITION_TO_DOUBLE,
+    STORE_AND_GROW_NO_TRANSITION_HANDLE_COW,
+    STORE_AND_GROW_TRANSITION_TO_OBJECT,
+    STORE_AND_GROW_TRANSITION_TO_DOUBLE,
+    STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,
+    STORE_NO_TRANSITION_HANDLE_COW
+};
+
+enum MutableMode { MUTABLE, IMMUTABLE };
+
+static inline bool IsTransitionStoreMode(KeyedAccessStoreMode store_mode) {
+    return store_mode == STORE_TRANSITION_TO_OBJECT ||
+           store_mode == STORE_TRANSITION_TO_DOUBLE ||
+           store_mode == STORE_AND_GROW_TRANSITION_TO_OBJECT ||
+           store_mode == STORE_AND_GROW_TRANSITION_TO_DOUBLE;
+}
+
+static inline bool IsCOWHandlingStoreMode(KeyedAccessStoreMode store_mode) {
+    return store_mode == STORE_NO_TRANSITION_HANDLE_COW ||
+           store_mode == STORE_AND_GROW_NO_TRANSITION_HANDLE_COW;
+}
+
+static inline KeyedAccessStoreMode GetNonTransitioningStoreMode(
+    KeyedAccessStoreMode store_mode, bool receiver_was_cow) {
+    switch (store_mode) {
+    case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
+    case STORE_AND_GROW_TRANSITION_TO_OBJECT:
+    case STORE_AND_GROW_TRANSITION_TO_DOUBLE:
+        store_mode = STORE_AND_GROW_NO_TRANSITION_HANDLE_COW;
+        break;
+    case STANDARD_STORE:
+    case STORE_TRANSITION_TO_OBJECT:
+    case STORE_TRANSITION_TO_DOUBLE:
+        store_mode =
+            receiver_was_cow ? STORE_NO_TRANSITION_HANDLE_COW : STANDARD_STORE;
+        break;
+    case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
+    case STORE_NO_TRANSITION_HANDLE_COW:
+        break;
+    }
+    DCHECK(!IsTransitionStoreMode(store_mode));
+    DCHECK_IMPLIES(receiver_was_cow, IsCOWHandlingStoreMode(store_mode));
+    return store_mode;
+}
+
+static inline bool IsGrowStoreMode(KeyedAccessStoreMode store_mode) {
+    return store_mode >= STORE_AND_GROW_NO_TRANSITION_HANDLE_COW &&
+           store_mode <= STORE_AND_GROW_TRANSITION_TO_DOUBLE;
+}
+
+enum IcCheckType { ELEMENT, PROPERTY };
 }  // namespace internal
 }  // namespace v8
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script-source.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script-source.h
index 381ff07d3..5afdf361b 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script-source.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script-source.h
@@ -1,3 +1,3 @@
 const char InjectedScriptSource_js[] = {
-    0x22, 0x75, 0x73, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x22, 0x3b, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2c, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x29, 0x7b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x75, 0x73, 0x68, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x76, 0x61, 0x72, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x3b, 0x69, 0x3c, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5b, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x3d, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x7c, 0x7c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x7c, 0x7c, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x23, 0x3c, 0x22, 0x2b, 0x6e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x3e, 0x22, 0x3b, 0x7d, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x30, 0x26, 0x26, 0x31, 0x2f, 0x6f, 0x62, 0x6a, 0x3c, 0x30, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2d, 0x30, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2b, 0x22, 0x6e, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x21, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2c, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6c, 0x65, 0x6e, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x26, 0x26, 0x6c, 0x65, 0x6e, 0x3e, 0x3e, 0x3e, 0x30, 0x3d, 0x3d, 0x3d, 0x6c, 0x65, 0x6e, 0x26, 0x26, 0x28, 0x6c, 0x65, 0x6e, 0x3e, 0x30, 0x7c, 0x7c, 0x31, 0x2f, 0x6c, 0x65, 0x6e, 0x3e, 0x30, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x61, 0x78, 0x28, 0x61, 0x2c, 0x62, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x3e, 0x62, 0x3f, 0x61, 0x3a, 0x62, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x3d, 0x7b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x3a, 0x7b, 0x62, 0x6f, 0x64, 0x79, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3a, 0x7b, 0x62, 0x6f, 0x64, 0x79, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x48, 0x61, 0x76, 0x65, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x5b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x5d, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x7b, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3d, 0x7b, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3d, 0x7b, 0x22, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x63, 0x61, 0x74, 0x63, 0x68, 0x22, 0x3a, 0x22, 0x43, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x3a, 0x22, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x65, 0x76, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x45, 0x76, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x7b, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5d, 0x26, 0x26, 0x21, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x50, 0x61, 0x73, 0x73, 0x42, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x26, 0x26, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3b, 0x7d, 0x2c, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x2c, 0x77, 0x72, 0x61, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x3d, 0x5b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x7b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x22, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x78, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x3c, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x22, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x64, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x7b, 0x5c, 0x22, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x5c, 0x22, 0x3a, 0x22, 0x2b, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x2b, 0x22, 0x2c, 0x5c, 0x22, 0x69, 0x64, 0x5c, 0x22, 0x3a, 0x22, 0x2b, 0x69, 0x64, 0x2b, 0x22, 0x7d, 0x22, 0x3b, 0x7d, 0x2c, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x29, 0x7b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x4f, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x3d, 0x7b, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3a, 0x28, 0x22, 0x22, 0x2b, 0x69, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3f, 0x28, 0x22, 0x22, 0x2b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3a, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x26, 0x26, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x21, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x42, 0x75, 0x69, 0x6c, 0x74, 0x69, 0x6e, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x68, 0x61, 0x73, 0x47, 0x65, 0x74, 0x74, 0x65, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x65, 0x74, 0x74, 0x65, 0x72, 0x28, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3b, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x68, 0x61, 0x73, 0x53, 0x65, 0x74, 0x74, 0x65, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x53, 0x65, 0x74, 0x74, 0x65, 0x72, 0x28, 0x76, 0x29, 0x7b, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3d, 0x76, 0x3b, 0x7d, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x7d, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x28, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x7c, 0x7c, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x26, 0x26, 0x21, 0x69, 0x73, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x6e, 0x61, 0x6d, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x26, 0x26, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x73, 0x41, 0x73, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x29, 0x26, 0x26, 0x21, 0x64, 0x6f, 0x65, 0x73, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x48, 0x61, 0x76, 0x65, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3b, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x65, 0x2c, 0x77, 0x61, 0x73, 0x54, 0x68, 0x72, 0x6f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x2c, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x3d, 0x3d, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x5b, 0x69, 0x5d, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x28, 0x6f, 0x29, 0x3b, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x7b, 0x6f, 0x3d, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x2c, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x5b, 0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x28, 0x6f, 0x29, 0x3b, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x7b, 0x6f, 0x3d, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x22, 0x3f, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x29, 0x7c, 0x7c, 0x5b, 0x5d, 0x3a, 0x5b, 0x5d, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x3d, 0x32, 0x29, 0x0a, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x69, 0x66, 0x28, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x26, 0x26, 0x6f, 0x3d, 0x3d, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x6f, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x26, 0x26, 0x21, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2c, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x61, 0x78, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3d, 0x32, 0x30, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3d, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x7c, 0x7c, 0x30, 0x29, 0x2b, 0x31, 0x0a, 0x74, 0x72, 0x79, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3e, 0x3d, 0x6d, 0x61, 0x78, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x29, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x64, 0x65, 0x65, 0x70, 0x20, 0x68, 0x69, 0x65, 0x72, 0x61, 0x72, 0x63, 0x68, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x73, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x30, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x3d, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x31, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x5b, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x3d, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x5b, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x3a, 0x20, 0x6f, 0x62, 0x6c, 0x69, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x5c, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5c, 0x22, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x22, 0x29, 0x3b, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x31, 0x5d, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x7d, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x2d, 0x2d, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x21, 0x21, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x7c, 0x7c, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x26, 0x26, 0x21, 0x21, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x2c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x72, 0x65, 0x67, 0x65, 0x78, 0x70, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x64, 0x61, 0x74, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x2e, 0x74, 0x6f, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x43, 0x61, 0x73, 0x65, 0x28, 0x29, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x2c, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x2e, 0x74, 0x6f, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x43, 0x61, 0x73, 0x65, 0x28, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x29, 0x3b, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x28, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x29, 0x7b, 0x63, 0x61, 0x73, 0x65, 0x20, 0x31, 0x3a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x64, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x29, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x3d, 0x69, 0x64, 0x3f, 0x22, 0x23, 0x22, 0x2b, 0x69, 0x64, 0x3a, 0x22, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x3d, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x26, 0x26, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x3f, 0x22, 0x2e, 0x22, 0x2b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2e, 0x74, 0x72, 0x69, 0x6d, 0x28, 0x29, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x28, 0x2f, 0x5c, 0x73, 0x2b, 0x2f, 0x67, 0x2c, 0x22, 0x2e, 0x22, 0x29, 0x3a, 0x22, 0x22, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x63, 0x61, 0x73, 0x65, 0x20, 0x31, 0x30, 0x3a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x22, 0x2b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x22, 0x3e, 0x22, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x69, 0x7a, 0x65, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x64, 0x61, 0x74, 0x61, 0x76, 0x69, 0x65, 0x77, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x62, 0x79, 0x74, 0x65, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x62, 0x79, 0x74, 0x65, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x29, 0x7c, 0x7c, 0x22, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x3b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x3d, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3f, 0x22, 0x3a, 0x20, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x22, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x43, 0x61, 0x6c, 0x6c, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x3d, 0x2f, 0x5e, 0x5c, 0x73, 0x2b, 0x61, 0x74, 0x5c, 0x73, 0x2f, 0x6d, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x28, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x64, 0x3d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x43, 0x61, 0x6c, 0x6c, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x3f, 0x66, 0x69, 0x72, 0x73, 0x74, 0x43, 0x61, 0x6c, 0x6c, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x3a, 0x2d, 0x31, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x64, 0x21, 0x3d, 0x3d, 0x2d, 0x31, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x54, 0x72, 0x61, 0x63, 0x65, 0x3d, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x64, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2b, 0x22, 0x5c, 0x6e, 0x22, 0x2b, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x54, 0x72, 0x61, 0x63, 0x65, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x7b, 0x22, 0x2b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6b, 0x65, 0x79, 0x29, 0x2b, 0x22, 0x20, 0x3d, 0x3e, 0x20, 0x22, 0x2b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2b, 0x22, 0x7d, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x5b, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x5d, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x6f, 0x62, 0x6a, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x5d, 0x7c, 0x7c, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x29, 0x2b, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3f, 0x22, 0x20, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x29, 0x22, 0x3a, 0x22, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x2c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x5c, 0x22, 0x22, 0x2b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x28, 0x2f, 0x5c, 0x6e, 0x2f, 0x67, 0x2c, 0x22, 0x5c, 0x75, 0x32, 0x31, 0x42, 0x35, 0x22, 0x29, 0x2b, 0x22, 0x5c, 0x22, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x22, 0x2b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3f, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3a, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x3b, 0x7d, 0x2c, 0x73, 0x65, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x29, 0x0a, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3d, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3b, 0x7d, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3d, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x28, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x26, 0x26, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7c, 0x7c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x7c, 0x7c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x7b, 0x63, 0x61, 0x73, 0x65, 0x22, 0x4e, 0x61, 0x4e, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x2d, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x2d, 0x30, 0x22, 0x3a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x75, 0x6e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x29, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x75, 0x6e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x50, 0x61, 0x73, 0x73, 0x42, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x26, 0x26, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x7b, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x29, 0x0a, 0x7b, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x28, 0x29, 0x2e, 0x74, 0x68, 0x65, 0x6e, 0x28, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x2e, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x2c, 0x22, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x20, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x3a, 0x20, 0x22, 0x2b, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x29, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x72, 0x61, 0x70, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x7d, 0x0a, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x3d, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x22, 0x64, 0x65, 0x76, 0x74, 0x6f, 0x6f, 0x6c, 0x73, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x22, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x7c, 0x7c, 0x21, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x3d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x3d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2e, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x77, 0x72, 0x61, 0x70, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3d, 0x7b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x3a, 0x4a, 0x53, 0x4f, 0x4e, 0x2e, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x69, 0x66, 0x79, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x2c, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x3a, 0x21, 0x21, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x2c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3a, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x2c, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x3a, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x22, 0x5d, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x2c, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x7b, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x29, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x7c, 0x7c, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2c, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x5b, 0x5d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x2c, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x3d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x3f, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3a, 0x30, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x3d, 0x7b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3f, 0x31, 0x30, 0x30, 0x30, 0x3a, 0x6d, 0x61, 0x78, 0x28, 0x35, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x29, 0x2c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x3a, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3f, 0x31, 0x30, 0x30, 0x30, 0x3a, 0x6d, 0x61, 0x78, 0x28, 0x31, 0x30, 0x30, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x29, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7c, 0x7c, 0x5b, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x3d, 0x32, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5d, 0x5d, 0x22, 0x29, 0x7b, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x5d, 0x5d, 0x22, 0x26, 0x26, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x3d, 0x3d, 0x3d, 0x27, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x27, 0x29, 0x0a, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x2b, 0x29, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x77, 0x65, 0x61, 0x6b, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x77, 0x65, 0x61, 0x6b, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x77, 0x61, 0x73, 0x54, 0x68, 0x72, 0x6f, 0x77, 0x6e, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x26, 0x26, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x29, 0x26, 0x26, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x27, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x27, 0x26, 0x26, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x38, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x55, 0x69, 0x6e, 0x74, 0x38, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x31, 0x36, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x26, 0x26, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x26, 0x26, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x3d, 0x3d, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3e, 0x3e, 0x3e, 0x30, 0x29, 0x3d, 0x3d, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x2d, 0x2d, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2d, 0x2d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x61, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x3e, 0x3d, 0x30, 0x26, 0x26, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3e, 0x3d, 0x30, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x63, 0x61, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x29, 0x7b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x26, 0x26, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x29, 0x0a, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x26, 0x26, 0x21, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x31, 0x30, 0x30, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x74, 0x79, 0x70, 0x65, 0x5d, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x3f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x7c, 0x7c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x7c, 0x7c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x29, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x72, 0x65, 0x67, 0x65, 0x78, 0x70, 0x22, 0x29, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x3d, 0x35, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x3d, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x29, 0x7b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x3d, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x69, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x6b, 0x65, 0x79, 0x3d, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x6b, 0x65, 0x79, 0x29, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x7c, 0x7c, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3c, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3b, 0x69, 0x66, 0x28, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x3e, 0x31, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x2d, 0x31, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x29, 0x2b, 0x22, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x36, 0x22, 0x2b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x30, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x2b, 0x22, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x36, 0x22, 0x3b, 0x7d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3b, 0x7d, 0x29
+    0x22, 0x75, 0x73, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x22, 0x3b, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2c, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x29, 0x7b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x75, 0x73, 0x68, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x76, 0x61, 0x72, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x3b, 0x69, 0x3c, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5b, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x3d, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x7c, 0x7c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x7c, 0x7c, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x23, 0x3c, 0x22, 0x2b, 0x6e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x3e, 0x22, 0x3b, 0x7d, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x30, 0x26, 0x26, 0x31, 0x2f, 0x6f, 0x62, 0x6a, 0x3c, 0x30, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2d, 0x30, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2b, 0x22, 0x6e, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x21, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2c, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6c, 0x65, 0x6e, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x26, 0x26, 0x6c, 0x65, 0x6e, 0x3e, 0x3e, 0x3e, 0x30, 0x3d, 0x3d, 0x3d, 0x6c, 0x65, 0x6e, 0x26, 0x26, 0x28, 0x6c, 0x65, 0x6e, 0x3e, 0x30, 0x7c, 0x7c, 0x31, 0x2f, 0x6c, 0x65, 0x6e, 0x3e, 0x30, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x61, 0x78, 0x28, 0x61, 0x2c, 0x62, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x3e, 0x62, 0x3f, 0x61, 0x3a, 0x62, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x3d, 0x7b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x3a, 0x7b, 0x62, 0x6f, 0x64, 0x79, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3a, 0x7b, 0x62, 0x6f, 0x64, 0x79, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x48, 0x61, 0x76, 0x65, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x6f, 0x6d, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x5b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x5d, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x7b, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3d, 0x7b, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3d, 0x7b, 0x22, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x63, 0x61, 0x74, 0x63, 0x68, 0x22, 0x3a, 0x22, 0x43, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x3a, 0x22, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x65, 0x76, 0x61, 0x6c, 0x22, 0x3a, 0x22, 0x45, 0x76, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x7b, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5d, 0x26, 0x26, 0x21, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x50, 0x61, 0x73, 0x73, 0x42, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x26, 0x26, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3b, 0x7d, 0x2c, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x2c, 0x77, 0x72, 0x61, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x3d, 0x5b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x7b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x22, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x78, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x3c, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3e, 0x22, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x64, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x7b, 0x5c, 0x22, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x5c, 0x22, 0x3a, 0x22, 0x2b, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x49, 0x64, 0x2b, 0x22, 0x2c, 0x5c, 0x22, 0x69, 0x64, 0x5c, 0x22, 0x3a, 0x22, 0x2b, 0x69, 0x64, 0x2b, 0x22, 0x7d, 0x22, 0x3b, 0x7d, 0x2c, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x29, 0x7b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3d, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x4f, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x3d, 0x7b, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3a, 0x28, 0x22, 0x22, 0x2b, 0x69, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3f, 0x28, 0x22, 0x22, 0x2b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3a, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x26, 0x26, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x21, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x42, 0x75, 0x69, 0x6c, 0x74, 0x69, 0x6e, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x68, 0x61, 0x73, 0x47, 0x65, 0x74, 0x74, 0x65, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x65, 0x74, 0x74, 0x65, 0x72, 0x28, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3b, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x68, 0x61, 0x73, 0x53, 0x65, 0x74, 0x74, 0x65, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x53, 0x65, 0x74, 0x74, 0x65, 0x72, 0x28, 0x76, 0x29, 0x7b, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3d, 0x76, 0x3b, 0x7d, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x6f, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x7d, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x28, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x7c, 0x7c, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x26, 0x26, 0x21, 0x69, 0x73, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x26, 0x26, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x27, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x7c, 0x7c, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x22, 0x67, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x22, 0x73, 0x65, 0x74, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x26, 0x26, 0x6e, 0x61, 0x6d, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x26, 0x26, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x73, 0x41, 0x73, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x29, 0x26, 0x26, 0x21, 0x64, 0x6f, 0x65, 0x73, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x48, 0x61, 0x76, 0x65, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x64, 0x65, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x4f, 0x6e, 0x47, 0x65, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x29, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x3b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x65, 0x74, 0x3b, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x65, 0x2c, 0x77, 0x61, 0x73, 0x54, 0x68, 0x72, 0x6f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x6f, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x2c, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x3d, 0x3d, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x5b, 0x69, 0x5d, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x28, 0x6f, 0x29, 0x3b, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x7b, 0x6f, 0x3d, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x2c, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x5b, 0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x26, 0x26, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x28, 0x6f, 0x29, 0x3b, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x7b, 0x6f, 0x3d, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x22, 0x3f, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x29, 0x7c, 0x7c, 0x5b, 0x5d, 0x3a, 0x5b, 0x5d, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x3d, 0x32, 0x29, 0x0a, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x69, 0x66, 0x28, 0x73, 0x6b, 0x69, 0x70, 0x47, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x26, 0x26, 0x6f, 0x3d, 0x3d, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x6f, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x21, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x28, 0x6f, 0x2c, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x73, 0x28, 0x6f, 0x29, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x26, 0x26, 0x21, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2c, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x6f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x61, 0x78, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3d, 0x32, 0x30, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3d, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x7c, 0x7c, 0x30, 0x29, 0x2b, 0x31, 0x0a, 0x74, 0x72, 0x79, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x3e, 0x3d, 0x6d, 0x61, 0x78, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x29, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x64, 0x65, 0x65, 0x70, 0x20, 0x68, 0x69, 0x65, 0x72, 0x61, 0x72, 0x63, 0x68, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x73, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x30, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x3d, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x31, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x5b, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x3d, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x5b, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x3a, 0x20, 0x6f, 0x62, 0x6c, 0x69, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x5c, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5c, 0x22, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x22, 0x29, 0x3b, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x31, 0x5d, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x6a, 0x73, 0x6f, 0x6e, 0x4d, 0x4c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x7d, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x52, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x74, 0x68, 0x2d, 0x2d, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x69, 0x73, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x21, 0x21, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x7c, 0x7c, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x26, 0x26, 0x21, 0x21, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x7d, 0x2c, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x2c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x72, 0x65, 0x67, 0x65, 0x78, 0x70, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x64, 0x61, 0x74, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x29, 0x7b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2c, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x7b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x2e, 0x74, 0x6f, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x43, 0x61, 0x73, 0x65, 0x28, 0x29, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x2c, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x2e, 0x74, 0x6f, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x43, 0x61, 0x73, 0x65, 0x28, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x29, 0x3b, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x28, 0x6e, 0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x29, 0x7b, 0x63, 0x61, 0x73, 0x65, 0x20, 0x31, 0x3a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x64, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x29, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x3d, 0x69, 0x64, 0x3f, 0x22, 0x23, 0x22, 0x2b, 0x69, 0x64, 0x3a, 0x22, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x22, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x3d, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x26, 0x26, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x3f, 0x22, 0x2e, 0x22, 0x2b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2e, 0x74, 0x72, 0x69, 0x6d, 0x28, 0x29, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x28, 0x2f, 0x5c, 0x73, 0x2b, 0x2f, 0x67, 0x2c, 0x22, 0x2e, 0x22, 0x29, 0x3a, 0x22, 0x22, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x63, 0x61, 0x73, 0x65, 0x20, 0x31, 0x30, 0x3a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x22, 0x2b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2b, 0x22, 0x3e, 0x22, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x69, 0x7a, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x69, 0x7a, 0x65, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x64, 0x61, 0x74, 0x61, 0x76, 0x69, 0x65, 0x77, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x62, 0x79, 0x74, 0x65, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x62, 0x79, 0x74, 0x65, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x29, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x3d, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x73, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x29, 0x7c, 0x7c, 0x22, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x22, 0x3b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3d, 0x3d, 0x3d, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x3d, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x30, 0x2c, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x3d, 0x3d, 0x3d, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x3b, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3b, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x3d, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x3d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x21, 0x3d, 0x3d, 0x2d, 0x31, 0x3f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x29, 0x3a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x2b, 0x27, 0x3a, 0x20, 0x27, 0x2b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x7b, 0x22, 0x2b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6b, 0x65, 0x79, 0x29, 0x2b, 0x22, 0x20, 0x3d, 0x3e, 0x20, 0x22, 0x2b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2b, 0x22, 0x7d, 0x22, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x5b, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2b, 0x22, 0x5d, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x23, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x6f, 0x62, 0x6a, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x5d, 0x7c, 0x7c, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x29, 0x2b, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3f, 0x22, 0x20, 0x28, 0x22, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x2b, 0x22, 0x29, 0x22, 0x3a, 0x22, 0x22, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x7d, 0x2c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x5c, 0x22, 0x22, 0x2b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x28, 0x2f, 0x5c, 0x6e, 0x2f, 0x67, 0x2c, 0x22, 0x5c, 0x75, 0x32, 0x31, 0x42, 0x35, 0x22, 0x29, 0x2b, 0x22, 0x5c, 0x22, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x22, 0x2b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3f, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3a, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x7c, 0x7c, 0x22, 0x22, 0x29, 0x3b, 0x7d, 0x2c, 0x73, 0x65, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x29, 0x0a, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3d, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3b, 0x7d, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3d, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x28, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x2c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x2c, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x26, 0x26, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7c, 0x7c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x7c, 0x7c, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x69, 0x66, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x29, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x7b, 0x63, 0x61, 0x73, 0x65, 0x22, 0x4e, 0x61, 0x4e, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x2d, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x63, 0x61, 0x73, 0x65, 0x22, 0x2d, 0x30, 0x22, 0x3a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x75, 0x6e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74, 0x22, 0x29, 0x7b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x75, 0x6e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x50, 0x61, 0x73, 0x73, 0x42, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x29, 0x7b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x64, 0x6f, 0x4e, 0x6f, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3d, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x26, 0x26, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x7d, 0x0a, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x7b, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x29, 0x0a, 0x7b, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x28, 0x29, 0x2e, 0x74, 0x68, 0x65, 0x6e, 0x28, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x2e, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x2c, 0x22, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x20, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x3a, 0x20, 0x22, 0x2b, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x29, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x72, 0x61, 0x70, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x7b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x7d, 0x0a, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x3d, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x22, 0x64, 0x65, 0x76, 0x74, 0x6f, 0x6f, 0x6c, 0x73, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x22, 0x5d, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x7c, 0x7c, 0x21, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x69, 0x6b, 0x65, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x3d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x3d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2e, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x3b, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x61, 0x67, 0x73, 0x49, 0x6e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x2c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x77, 0x72, 0x61, 0x70, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3d, 0x7b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x3a, 0x4a, 0x53, 0x4f, 0x4e, 0x2e, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x69, 0x66, 0x79, 0x28, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x29, 0x2c, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x3a, 0x21, 0x21, 0x68, 0x61, 0x73, 0x42, 0x6f, 0x64, 0x79, 0x2c, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x3a, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x2c, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x3a, 0x62, 0x69, 0x6e, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x0a, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x22, 0x5d, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2c, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x7d, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x6c, 0x6f, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x65, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x7d, 0x2c, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x7b, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x29, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x7c, 0x7c, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2c, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x5b, 0x5d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x2c, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x3d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x3f, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3a, 0x30, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x3d, 0x7b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3a, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3f, 0x31, 0x30, 0x30, 0x30, 0x3a, 0x6d, 0x61, 0x78, 0x28, 0x35, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x29, 0x2c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x3a, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x3f, 0x31, 0x30, 0x30, 0x30, 0x3a, 0x6d, 0x61, 0x78, 0x28, 0x31, 0x30, 0x30, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x29, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3b, 0x74, 0x72, 0x79, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3d, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x67, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x7c, 0x7c, 0x5b, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x3d, 0x32, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5d, 0x5d, 0x22, 0x29, 0x7b, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x5d, 0x5d, 0x22, 0x26, 0x26, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x3d, 0x3d, 0x3d, 0x27, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x27, 0x29, 0x0a, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x72, 0x61, 0x77, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x2b, 0x31, 0x5d, 0x2c, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x65, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x29, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x69, 0x2b, 0x2b, 0x29, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x77, 0x65, 0x61, 0x6b, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x77, 0x65, 0x61, 0x6b, 0x73, 0x65, 0x74, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x29, 0x0a, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x3b, 0x7d, 0x63, 0x61, 0x74, 0x63, 0x68, 0x28, 0x65, 0x29, 0x7b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x49, 0x66, 0x4e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x77, 0x61, 0x73, 0x54, 0x68, 0x72, 0x6f, 0x77, 0x6e, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x74, 0x79, 0x70, 0x65, 0x64, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x29, 0x26, 0x26, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x7c, 0x7c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x65, 0x74, 0x22, 0x29, 0x26, 0x26, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x27, 0x61, 0x72, 0x72, 0x61, 0x79, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x27, 0x26, 0x26, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x38, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x55, 0x69, 0x6e, 0x74, 0x38, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x31, 0x36, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x7c, 0x7c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x5b, 0x5b, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x41, 0x72, 0x72, 0x61, 0x79, 0x5d, 0x5d, 0x22, 0x29, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x69, 0x73, 0x4f, 0x77, 0x6e, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x26, 0x26, 0x21, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x26, 0x26, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x3d, 0x3d, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3e, 0x3e, 0x3e, 0x30, 0x29, 0x3d, 0x3d, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x2d, 0x2d, 0x3b, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2d, 0x2d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x63, 0x61, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x3e, 0x3d, 0x30, 0x26, 0x26, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x3e, 0x3d, 0x30, 0x3b, 0x69, 0x66, 0x28, 0x21, 0x63, 0x61, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x29, 0x7b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x7d, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x0a, 0x7b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x22, 0x26, 0x26, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x69, 0x73, 0x48, 0x54, 0x4d, 0x4c, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x29, 0x0a, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x67, 0x65, 0x74, 0x26, 0x26, 0x21, 0x28, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x7b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3d, 0x31, 0x30, 0x30, 0x3b, 0x69, 0x66, 0x28, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5b, 0x74, 0x79, 0x70, 0x65, 0x5d, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x3f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x29, 0x3b, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3d, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x29, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x3d, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x7c, 0x7c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4b, 0x65, 0x79, 0x73, 0x7c, 0x7c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x69, 0x73, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x75, 0x62, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x7d, 0x65, 0x6c, 0x73, 0x65, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x22, 0x3b, 0x69, 0x66, 0x28, 0x74, 0x79, 0x70, 0x65, 0x21, 0x3d, 0x3d, 0x22, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x28, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x29, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x3d, 0x3d, 0x22, 0x72, 0x65, 0x67, 0x65, 0x78, 0x70, 0x22, 0x29, 0x3b, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x7d, 0x0a, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2c, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x21, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x69, 0x66, 0x28, 0x73, 0x6b, 0x69, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x7d, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3d, 0x5b, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x3d, 0x35, 0x3b, 0x66, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x2b, 0x2b, 0x69, 0x29, 0x7b, 0x69, 0x66, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x3d, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x29, 0x7b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x6f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x3d, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x7d, 0x0a, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x3d, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x5b, 0x69, 0x5d, 0x3b, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x3d, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x3b, 0x69, 0x66, 0x28, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x69, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x0a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x6b, 0x65, 0x79, 0x3d, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x6b, 0x65, 0x79, 0x29, 0x3b, 0x70, 0x75, 0x73, 0x68, 0x28, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x29, 0x3b, 0x7d, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x0a, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3d, 0x6e, 0x65, 0x77, 0x20, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x74, 0x72, 0x75, 0x65, 0x29, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x7c, 0x7c, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x28, 0x29, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x3b, 0x7d, 0x7d, 0x2c, 0x5f, 0x61, 0x62, 0x62, 0x72, 0x65, 0x76, 0x69, 0x61, 0x74, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2c, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x29, 0x0a, 0x7b, 0x69, 0x66, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3c, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3b, 0x69, 0x66, 0x28, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x29, 0x7b, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3e, 0x3e, 0x31, 0x3b, 0x76, 0x61, 0x72, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x3d, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x2d, 0x31, 0x3b, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x29, 0x2b, 0x22, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x36, 0x22, 0x2b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x48, 0x61, 0x6c, 0x66, 0x29, 0x3b, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x28, 0x30, 0x2c, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x2b, 0x22, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x36, 0x22, 0x3b, 0x7d, 0x2c, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f, 0x3a, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x3b, 0x7d, 0x29
 };
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.cc
index 5852b227e..296dc4c63 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.cc
@@ -204,6 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
     v8::Isolate* isolate = session->inspector()->isolate();
     if (result->IsNativeError()) {
       message = " " + toProtocolString(
+                          isolate,
                           result->ToDetailString(isolate->GetCurrentContext())
                               .ToLocalChecked());
       v8::Local<v8::StackTrace> stackTrace = v8::debug::GetDetailedStackTrace(
@@ -564,7 +565,9 @@ Response InjectedScript::createExceptionDetails(
   v8::Local<v8::Message> message = tryCatch.Message();
   v8::Local<v8::Value> exception = tryCatch.Exception();
   String16 messageText =
-      message.IsEmpty() ? String16() : toProtocolString(message->Get());
+      message.IsEmpty()
+          ? String16()
+          : toProtocolString(m_context->isolate(), message->Get());
   std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
       protocol::Runtime::ExceptionDetails::create()
           .setExceptionId(m_context->inspector()->nextExceptionId())
@@ -735,7 +738,7 @@ InjectedScript::ContextScope::ContextScope(V8InspectorSessionImpl* session,
     : InjectedScript::Scope(session),
       m_executionContextId(executionContextId) {}
 
-InjectedScript::ContextScope::~ContextScope() {}
+InjectedScript::ContextScope::~ContextScope() = default;
 
 Response InjectedScript::ContextScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
@@ -746,7 +749,7 @@ InjectedScript::ObjectScope::ObjectScope(V8InspectorSessionImpl* session,
                                          const String16& remoteObjectId)
     : InjectedScript::Scope(session), m_remoteObjectId(remoteObjectId) {}
 
-InjectedScript::ObjectScope::~ObjectScope() {}
+InjectedScript::ObjectScope::~ObjectScope() = default;
 
 Response InjectedScript::ObjectScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
@@ -767,7 +770,7 @@ InjectedScript::CallFrameScope::CallFrameScope(V8InspectorSessionImpl* session,
                                                const String16& remoteObjectId)
     : InjectedScript::Scope(session), m_remoteCallFrameId(remoteObjectId) {}
 
-InjectedScript::CallFrameScope::~CallFrameScope() {}
+InjectedScript::CallFrameScope::~CallFrameScope() = default;
 
 Response InjectedScript::CallFrameScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.h
index 1a49d4e31..88ca3b720 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/injected-script.h
@@ -60,7 +60,7 @@ class EvaluateCallback {
             protocol::Maybe<protocol::Runtime::ExceptionDetails>
             exceptionDetails) = 0;
         virtual void sendFailure(const protocol::DispatchResponse& response) = 0;
-        virtual ~EvaluateCallback() {}
+        virtual ~EvaluateCallback() = default;
 };
 
 class InjectedScript final {
@@ -161,7 +161,7 @@ class InjectedScript final {
         class ContextScope : public Scope {
             public:
                 ContextScope(V8InspectorSessionImpl*, int executionContextId);
-                ~ContextScope();
+                ~ContextScope() override;
 
             private:
                 Response findInjectedScript(V8InspectorSessionImpl*) override;
@@ -173,7 +173,7 @@ class InjectedScript final {
         class ObjectScope : public Scope {
             public:
                 ObjectScope(V8InspectorSessionImpl*, const String16& remoteObjectId);
-                ~ObjectScope();
+                ~ObjectScope() override;
                 const String16& objectGroupName() const {
                     return m_objectGroupName;
                 }
@@ -193,7 +193,7 @@ class InjectedScript final {
         class CallFrameScope : public Scope {
             public:
                 CallFrameScope(V8InspectorSessionImpl*, const String16& remoteCallFrameId);
-                ~CallFrameScope();
+                ~CallFrameScope() override;
                 size_t frameOrdinal() const {
                     return m_frameOrdinal;
                 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/CSS.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/CSS.cpp
index 3d538b5bd..e17540be2 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/CSS.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/CSS.cpp
@@ -1210,10 +1210,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["CSS.addRule"] = &DispatcherImpl::addRule;
             m_dispatchMap["CSS.collectClassNames"] = &DispatcherImpl::collectClassNames;
             m_dispatchMap["CSS.createStyleSheet"] = &DispatcherImpl::createStyleSheet;
@@ -1238,60 +1237,57 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["CSS.takeCoverageDelta"] = &DispatcherImpl::takeCoverageDelta;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status addRule(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status collectClassNames(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status createStyleSheet(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status forcePseudoState(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getBackgroundColors(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getComputedStyleForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getInlineStylesForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getMatchedStylesForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getMediaQueries(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getPlatformFontsForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getStyleSheetText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setEffectivePropertyValueForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setKeyframeKey(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setMediaText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setRuleSelector(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setStyleSheetText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setStyleTexts(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startRuleUsageTracking(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopRuleUsageTracking(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status takeCoverageDelta(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void addRule(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void collectClassNames(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void createStyleSheet(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void forcePseudoState(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getBackgroundColors(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getComputedStyleForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getInlineStylesForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getMatchedStylesForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getMediaQueries(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getPlatformFontsForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getStyleSheetText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setEffectivePropertyValueForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setKeyframeKey(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setMediaText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setRuleSelector(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setStyleSheetText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setStyleTexts(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startRuleUsageTracking(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopRuleUsageTracking(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void takeCoverageDelta(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::addRule(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::addRule(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1307,7 +1303,7 @@ DispatchResponse::Status DispatcherImpl::addRule(int callId, std::unique_ptr<Dic
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::CSS::CSSRule> out_rule;
@@ -1315,7 +1311,8 @@ DispatchResponse::Status DispatcherImpl::addRule(int callId, std::unique_ptr<Dic
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->addRule(in_styleSheetId, in_ruleText, std::move(in_location), &out_rule);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1324,10 +1321,10 @@ DispatchResponse::Status DispatcherImpl::addRule(int callId, std::unique_ptr<Dic
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::collectClassNames(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::collectClassNames(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1337,7 +1334,7 @@ DispatchResponse::Status DispatcherImpl::collectClassNames(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<String>> out_classNames;
@@ -1345,7 +1342,8 @@ DispatchResponse::Status DispatcherImpl::collectClassNames(int callId, std::uniq
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->collectClassNames(in_styleSheetId, &out_classNames);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1354,10 +1352,10 @@ DispatchResponse::Status DispatcherImpl::collectClassNames(int callId, std::uniq
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::createStyleSheet(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::createStyleSheet(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1367,7 +1365,7 @@ DispatchResponse::Status DispatcherImpl::createStyleSheet(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_styleSheetId;
@@ -1375,7 +1373,8 @@ DispatchResponse::Status DispatcherImpl::createStyleSheet(int callId, std::uniqu
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->createStyleSheet(in_frameId, &out_styleSheetId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1384,36 +1383,38 @@ DispatchResponse::Status DispatcherImpl::createStyleSheet(int callId, std::uniqu
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::forcePseudoState(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::forcePseudoState(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1426,21 +1427,22 @@ DispatchResponse::Status DispatcherImpl::forcePseudoState(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->forcePseudoState(in_nodeId, std::move(in_forcedPseudoClasses));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getBackgroundColors(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getBackgroundColors(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1450,7 +1452,7 @@ DispatchResponse::Status DispatcherImpl::getBackgroundColors(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<protocol::Array<String>> out_backgroundColors;
@@ -1461,7 +1463,8 @@ DispatchResponse::Status DispatcherImpl::getBackgroundColors(int callId, std::un
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getBackgroundColors(in_nodeId, &out_backgroundColors, &out_computedFontSize, &out_computedFontWeight, &out_computedBodyFontSize);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1481,10 +1484,10 @@ DispatchResponse::Status DispatcherImpl::getBackgroundColors(int callId, std::un
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getComputedStyleForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getComputedStyleForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1494,7 +1497,7 @@ DispatchResponse::Status DispatcherImpl::getComputedStyleForNode(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::CSSComputedStyleProperty>> out_computedStyle;
@@ -1502,7 +1505,8 @@ DispatchResponse::Status DispatcherImpl::getComputedStyleForNode(int callId, std
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getComputedStyleForNode(in_nodeId, &out_computedStyle);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1511,10 +1515,10 @@ DispatchResponse::Status DispatcherImpl::getComputedStyleForNode(int callId, std
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getInlineStylesForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getInlineStylesForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1524,7 +1528,7 @@ DispatchResponse::Status DispatcherImpl::getInlineStylesForNode(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<protocol::CSS::CSSStyle> out_inlineStyle;
@@ -1533,7 +1537,8 @@ DispatchResponse::Status DispatcherImpl::getInlineStylesForNode(int callId, std:
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getInlineStylesForNode(in_nodeId, &out_inlineStyle, &out_attributesStyle);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1547,10 +1552,10 @@ DispatchResponse::Status DispatcherImpl::getInlineStylesForNode(int callId, std:
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getMatchedStylesForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getMatchedStylesForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1560,7 +1565,7 @@ DispatchResponse::Status DispatcherImpl::getMatchedStylesForNode(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<protocol::CSS::CSSStyle> out_inlineStyle;
@@ -1573,7 +1578,8 @@ DispatchResponse::Status DispatcherImpl::getMatchedStylesForNode(int callId, std
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getMatchedStylesForNode(in_nodeId, &out_inlineStyle, &out_attributesStyle, &out_matchedCSSRules, &out_pseudoElements, &out_inherited, &out_cssKeyframesRules);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1599,17 +1605,18 @@ DispatchResponse::Status DispatcherImpl::getMatchedStylesForNode(int callId, std
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getMediaQueries(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getMediaQueries(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::CSSMedia>> out_medias;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getMediaQueries(&out_medias);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1618,10 +1625,10 @@ DispatchResponse::Status DispatcherImpl::getMediaQueries(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getPlatformFontsForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getPlatformFontsForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1631,7 +1638,7 @@ DispatchResponse::Status DispatcherImpl::getPlatformFontsForNode(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::PlatformFontUsage>> out_fonts;
@@ -1639,7 +1646,8 @@ DispatchResponse::Status DispatcherImpl::getPlatformFontsForNode(int callId, std
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getPlatformFontsForNode(in_nodeId, &out_fonts);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1648,10 +1656,10 @@ DispatchResponse::Status DispatcherImpl::getPlatformFontsForNode(int callId, std
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getStyleSheetText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getStyleSheetText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1661,7 +1669,7 @@ DispatchResponse::Status DispatcherImpl::getStyleSheetText(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_text;
@@ -1669,7 +1677,8 @@ DispatchResponse::Status DispatcherImpl::getStyleSheetText(int callId, std::uniq
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getStyleSheetText(in_styleSheetId, &out_text);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1678,10 +1687,10 @@ DispatchResponse::Status DispatcherImpl::getStyleSheetText(int callId, std::uniq
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setEffectivePropertyValueForNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setEffectivePropertyValueForNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1697,21 +1706,22 @@ DispatchResponse::Status DispatcherImpl::setEffectivePropertyValueForNode(int ca
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setEffectivePropertyValueForNode(in_nodeId, in_propertyName, in_value);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setKeyframeKey(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setKeyframeKey(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1727,7 +1737,7 @@ DispatchResponse::Status DispatcherImpl::setKeyframeKey(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::CSS::Value> out_keyText;
@@ -1735,7 +1745,8 @@ DispatchResponse::Status DispatcherImpl::setKeyframeKey(int callId, std::unique_
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setKeyframeKey(in_styleSheetId, std::move(in_range), in_keyText, &out_keyText);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1744,10 +1755,10 @@ DispatchResponse::Status DispatcherImpl::setKeyframeKey(int callId, std::unique_
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setMediaText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setMediaText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1763,7 +1774,7 @@ DispatchResponse::Status DispatcherImpl::setMediaText(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::CSS::CSSMedia> out_media;
@@ -1771,7 +1782,8 @@ DispatchResponse::Status DispatcherImpl::setMediaText(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setMediaText(in_styleSheetId, std::move(in_range), in_text, &out_media);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1780,10 +1792,10 @@ DispatchResponse::Status DispatcherImpl::setMediaText(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setRuleSelector(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setRuleSelector(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1799,7 +1811,7 @@ DispatchResponse::Status DispatcherImpl::setRuleSelector(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::CSS::SelectorList> out_selectorList;
@@ -1807,7 +1819,8 @@ DispatchResponse::Status DispatcherImpl::setRuleSelector(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setRuleSelector(in_styleSheetId, std::move(in_range), in_selector, &out_selectorList);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1816,10 +1829,10 @@ DispatchResponse::Status DispatcherImpl::setRuleSelector(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setStyleSheetText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setStyleSheetText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1832,7 +1845,7 @@ DispatchResponse::Status DispatcherImpl::setStyleSheetText(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<String> out_sourceMapURL;
@@ -1840,7 +1853,8 @@ DispatchResponse::Status DispatcherImpl::setStyleSheetText(int callId, std::uniq
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setStyleSheetText(in_styleSheetId, in_text, &out_sourceMapURL);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1851,10 +1865,10 @@ DispatchResponse::Status DispatcherImpl::setStyleSheetText(int callId, std::uniq
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setStyleTexts(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setStyleTexts(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1864,7 +1878,7 @@ DispatchResponse::Status DispatcherImpl::setStyleTexts(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::CSSStyle>> out_styles;
@@ -1872,7 +1886,8 @@ DispatchResponse::Status DispatcherImpl::setStyleTexts(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setStyleTexts(std::move(in_edits), &out_styles);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1881,30 +1896,32 @@ DispatchResponse::Status DispatcherImpl::setStyleTexts(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startRuleUsageTracking(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startRuleUsageTracking(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startRuleUsageTracking();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopRuleUsageTracking(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopRuleUsageTracking(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>> out_ruleUsage;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopRuleUsageTracking(&out_ruleUsage);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1913,17 +1930,18 @@ DispatchResponse::Status DispatcherImpl::stopRuleUsageTracking(int callId, std::
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::takeCoverageDelta(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::takeCoverageDelta(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>> out_coverage;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->takeCoverageDelta(&out_coverage);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1932,12 +1950,12 @@ DispatchResponse::Status DispatcherImpl::takeCoverageDelta(int callId, std::uniq
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("CSS", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Console.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Console.cpp
index 90f623321..1f3118d39 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Console.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Console.cpp
@@ -155,91 +155,90 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Console.clearMessages"] = &DispatcherImpl::clearMessages;
             m_dispatchMap["Console.disable"] = &DispatcherImpl::disable;
             m_dispatchMap["Console.enable"] = &DispatcherImpl::enable;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status clearMessages(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void clearMessages(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::clearMessages(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::clearMessages(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->clearMessages();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Console", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/DOM.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/DOM.cpp
index 3fdb16c82..0c38e7ce8 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/DOM.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/DOM.cpp
@@ -1104,10 +1104,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["DOM.collectClassNamesFromSubtree"] = &DispatcherImpl::collectClassNamesFromSubtree;
             m_dispatchMap["DOM.copyTo"] = &DispatcherImpl::copyTo;
             m_dispatchMap["DOM.describeNode"] = &DispatcherImpl::describeNode;
@@ -1150,75 +1149,72 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["DOM.getFrameOwner"] = &DispatcherImpl::getFrameOwner;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status collectClassNamesFromSubtree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status copyTo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status describeNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status discardSearchResults(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status focus(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getAttributes(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getBoxModel(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getFlattenedDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getNodeForLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getOuterHTML(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getRelayoutBoundary(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getSearchResults(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status markUndoableState(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status moveTo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status performSearch(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status pushNodeByPathToFrontend(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status pushNodesByBackendIdsToFrontend(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status querySelector(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status querySelectorAll(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status redo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeAttribute(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status requestChildNodes(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status requestNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status resolveNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setAttributeValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setAttributesAsText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setFileInputFiles(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setInspectedNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setNodeName(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setNodeValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setOuterHTML(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status undo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getFrameOwner(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void collectClassNamesFromSubtree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void copyTo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void describeNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void discardSearchResults(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void focus(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getAttributes(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getBoxModel(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getFlattenedDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getNodeForLocation(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getOuterHTML(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getRelayoutBoundary(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getSearchResults(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void markUndoableState(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void moveTo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void performSearch(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void pushNodeByPathToFrontend(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void pushNodesByBackendIdsToFrontend(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void querySelector(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void querySelectorAll(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void redo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeAttribute(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void requestChildNodes(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void requestNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void resolveNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setAttributeValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setAttributesAsText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setFileInputFiles(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setInspectedNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setNodeName(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setNodeValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setOuterHTML(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void undo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getFrameOwner(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::collectClassNamesFromSubtree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::collectClassNamesFromSubtree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1228,7 +1224,7 @@ DispatchResponse::Status DispatcherImpl::collectClassNamesFromSubtree(int callId
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<String>> out_classNames;
@@ -1236,7 +1232,8 @@ DispatchResponse::Status DispatcherImpl::collectClassNamesFromSubtree(int callId
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->collectClassNamesFromSubtree(in_nodeId, &out_classNames);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1245,10 +1242,10 @@ DispatchResponse::Status DispatcherImpl::collectClassNamesFromSubtree(int callId
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::copyTo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::copyTo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1267,7 +1264,7 @@ DispatchResponse::Status DispatcherImpl::copyTo(int callId, std::unique_ptr<Dict
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1275,7 +1272,8 @@ DispatchResponse::Status DispatcherImpl::copyTo(int callId, std::unique_ptr<Dict
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->copyTo(in_nodeId, in_targetNodeId, std::move(in_insertBeforeNodeId), &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1284,10 +1282,10 @@ DispatchResponse::Status DispatcherImpl::copyTo(int callId, std::unique_ptr<Dict
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::describeNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::describeNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1324,7 +1322,7 @@ DispatchResponse::Status DispatcherImpl::describeNode(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::DOM::Node> out_node;
@@ -1332,7 +1330,8 @@ DispatchResponse::Status DispatcherImpl::describeNode(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->describeNode(std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId), std::move(in_depth), std::move(in_pierce), &out_node);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1341,23 +1340,24 @@ DispatchResponse::Status DispatcherImpl::describeNode(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::discardSearchResults(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::discardSearchResults(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1367,34 +1367,36 @@ DispatchResponse::Status DispatcherImpl::discardSearchResults(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->discardSearchResults(in_searchId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::focus(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::focus(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1419,21 +1421,22 @@ DispatchResponse::Status DispatcherImpl::focus(int callId, std::unique_ptr<Dicti
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->focus(std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getAttributes(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getAttributes(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1443,7 +1446,7 @@ DispatchResponse::Status DispatcherImpl::getAttributes(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<String>> out_attributes;
@@ -1451,7 +1454,8 @@ DispatchResponse::Status DispatcherImpl::getAttributes(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getAttributes(in_nodeId, &out_attributes);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1460,10 +1464,10 @@ DispatchResponse::Status DispatcherImpl::getAttributes(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getBoxModel(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getBoxModel(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1488,7 +1492,7 @@ DispatchResponse::Status DispatcherImpl::getBoxModel(int callId, std::unique_ptr
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::DOM::BoxModel> out_model;
@@ -1496,7 +1500,8 @@ DispatchResponse::Status DispatcherImpl::getBoxModel(int callId, std::unique_ptr
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getBoxModel(std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId), &out_model);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1505,10 +1510,10 @@ DispatchResponse::Status DispatcherImpl::getBoxModel(int callId, std::unique_ptr
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1527,7 +1532,7 @@ DispatchResponse::Status DispatcherImpl::getDocument(int callId, std::unique_ptr
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::DOM::Node> out_root;
@@ -1535,7 +1540,8 @@ DispatchResponse::Status DispatcherImpl::getDocument(int callId, std::unique_ptr
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getDocument(std::move(in_depth), std::move(in_pierce), &out_root);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1544,10 +1550,10 @@ DispatchResponse::Status DispatcherImpl::getDocument(int callId, std::unique_ptr
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getFlattenedDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getFlattenedDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1566,7 +1572,7 @@ DispatchResponse::Status DispatcherImpl::getFlattenedDocument(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::DOM::Node>> out_nodes;
@@ -1574,7 +1580,8 @@ DispatchResponse::Status DispatcherImpl::getFlattenedDocument(int callId, std::u
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getFlattenedDocument(std::move(in_depth), std::move(in_pierce), &out_nodes);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1583,10 +1590,10 @@ DispatchResponse::Status DispatcherImpl::getFlattenedDocument(int callId, std::u
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getNodeForLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getNodeForLocation(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1605,7 +1612,7 @@ DispatchResponse::Status DispatcherImpl::getNodeForLocation(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1613,7 +1620,8 @@ DispatchResponse::Status DispatcherImpl::getNodeForLocation(int callId, std::uni
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getNodeForLocation(in_x, in_y, std::move(in_includeUserAgentShadowDOM), &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1622,10 +1630,10 @@ DispatchResponse::Status DispatcherImpl::getNodeForLocation(int callId, std::uni
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getOuterHTML(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getOuterHTML(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1650,7 +1658,7 @@ DispatchResponse::Status DispatcherImpl::getOuterHTML(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_outerHTML;
@@ -1658,7 +1666,8 @@ DispatchResponse::Status DispatcherImpl::getOuterHTML(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getOuterHTML(std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId), &out_outerHTML);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1667,10 +1676,10 @@ DispatchResponse::Status DispatcherImpl::getOuterHTML(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getRelayoutBoundary(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getRelayoutBoundary(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1680,7 +1689,7 @@ DispatchResponse::Status DispatcherImpl::getRelayoutBoundary(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1688,7 +1697,8 @@ DispatchResponse::Status DispatcherImpl::getRelayoutBoundary(int callId, std::un
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getRelayoutBoundary(in_nodeId, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1697,10 +1707,10 @@ DispatchResponse::Status DispatcherImpl::getRelayoutBoundary(int callId, std::un
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getSearchResults(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getSearchResults(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1716,7 +1726,7 @@ DispatchResponse::Status DispatcherImpl::getSearchResults(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<int>> out_nodeIds;
@@ -1724,7 +1734,8 @@ DispatchResponse::Status DispatcherImpl::getSearchResults(int callId, std::uniqu
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getSearchResults(in_searchId, in_fromIndex, in_toIndex, &out_nodeIds);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1733,23 +1744,24 @@ DispatchResponse::Status DispatcherImpl::getSearchResults(int callId, std::uniqu
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::markUndoableState(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::markUndoableState(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->markUndoableState();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::moveTo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::moveTo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1768,7 +1780,7 @@ DispatchResponse::Status DispatcherImpl::moveTo(int callId, std::unique_ptr<Dict
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1776,7 +1788,8 @@ DispatchResponse::Status DispatcherImpl::moveTo(int callId, std::unique_ptr<Dict
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->moveTo(in_nodeId, in_targetNodeId, std::move(in_insertBeforeNodeId), &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1785,10 +1798,10 @@ DispatchResponse::Status DispatcherImpl::moveTo(int callId, std::unique_ptr<Dict
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::performSearch(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::performSearch(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1804,7 +1817,7 @@ DispatchResponse::Status DispatcherImpl::performSearch(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_searchId;
@@ -1813,7 +1826,8 @@ DispatchResponse::Status DispatcherImpl::performSearch(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->performSearch(in_query, std::move(in_includeUserAgentShadowDOM), &out_searchId, &out_resultCount);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1823,10 +1837,10 @@ DispatchResponse::Status DispatcherImpl::performSearch(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::pushNodeByPathToFrontend(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::pushNodeByPathToFrontend(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1836,7 +1850,7 @@ DispatchResponse::Status DispatcherImpl::pushNodeByPathToFrontend(int callId, st
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1844,7 +1858,8 @@ DispatchResponse::Status DispatcherImpl::pushNodeByPathToFrontend(int callId, st
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->pushNodeByPathToFrontend(in_path, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1853,10 +1868,10 @@ DispatchResponse::Status DispatcherImpl::pushNodeByPathToFrontend(int callId, st
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::pushNodesByBackendIdsToFrontend(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::pushNodesByBackendIdsToFrontend(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1866,7 +1881,7 @@ DispatchResponse::Status DispatcherImpl::pushNodesByBackendIdsToFrontend(int cal
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<int>> out_nodeIds;
@@ -1874,7 +1889,8 @@ DispatchResponse::Status DispatcherImpl::pushNodesByBackendIdsToFrontend(int cal
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->pushNodesByBackendIdsToFrontend(std::move(in_backendNodeIds), &out_nodeIds);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1883,10 +1899,10 @@ DispatchResponse::Status DispatcherImpl::pushNodesByBackendIdsToFrontend(int cal
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::querySelector(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::querySelector(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1899,7 +1915,7 @@ DispatchResponse::Status DispatcherImpl::querySelector(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -1907,7 +1923,8 @@ DispatchResponse::Status DispatcherImpl::querySelector(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->querySelector(in_nodeId, in_selector, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1916,10 +1933,10 @@ DispatchResponse::Status DispatcherImpl::querySelector(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::querySelectorAll(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::querySelectorAll(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1932,7 +1949,7 @@ DispatchResponse::Status DispatcherImpl::querySelectorAll(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<int>> out_nodeIds;
@@ -1940,7 +1957,8 @@ DispatchResponse::Status DispatcherImpl::querySelectorAll(int callId, std::uniqu
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->querySelectorAll(in_nodeId, in_selector, &out_nodeIds);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1949,23 +1967,24 @@ DispatchResponse::Status DispatcherImpl::querySelectorAll(int callId, std::uniqu
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::redo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::redo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->redo();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeAttribute(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeAttribute(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1978,21 +1997,22 @@ DispatchResponse::Status DispatcherImpl::removeAttribute(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeAttribute(in_nodeId, in_name);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2002,21 +2022,22 @@ DispatchResponse::Status DispatcherImpl::removeNode(int callId, std::unique_ptr<
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeNode(in_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::requestChildNodes(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::requestChildNodes(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2038,21 +2059,22 @@ DispatchResponse::Status DispatcherImpl::requestChildNodes(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->requestChildNodes(in_nodeId, std::move(in_depth), std::move(in_pierce));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::requestNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::requestNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2062,7 +2084,7 @@ DispatchResponse::Status DispatcherImpl::requestNode(int callId, std::unique_ptr
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -2070,7 +2092,8 @@ DispatchResponse::Status DispatcherImpl::requestNode(int callId, std::unique_ptr
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->requestNode(in_objectId, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2079,10 +2102,10 @@ DispatchResponse::Status DispatcherImpl::requestNode(int callId, std::unique_ptr
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::resolveNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::resolveNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2107,7 +2130,7 @@ DispatchResponse::Status DispatcherImpl::resolveNode(int callId, std::unique_ptr
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Runtime::RemoteObject> out_object;
@@ -2115,7 +2138,8 @@ DispatchResponse::Status DispatcherImpl::resolveNode(int callId, std::unique_ptr
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->resolveNode(std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectGroup), &out_object);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2124,10 +2148,10 @@ DispatchResponse::Status DispatcherImpl::resolveNode(int callId, std::unique_ptr
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setAttributeValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setAttributeValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2143,21 +2167,22 @@ DispatchResponse::Status DispatcherImpl::setAttributeValue(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setAttributeValue(in_nodeId, in_name, in_value);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setAttributesAsText(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setAttributesAsText(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2176,21 +2201,22 @@ DispatchResponse::Status DispatcherImpl::setAttributesAsText(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setAttributesAsText(in_nodeId, in_text, std::move(in_name));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setFileInputFiles(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setFileInputFiles(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2218,21 +2244,22 @@ DispatchResponse::Status DispatcherImpl::setFileInputFiles(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setFileInputFiles(std::move(in_files), std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setInspectedNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setInspectedNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2242,21 +2269,22 @@ DispatchResponse::Status DispatcherImpl::setInspectedNode(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setInspectedNode(in_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setNodeName(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setNodeName(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2269,7 +2297,7 @@ DispatchResponse::Status DispatcherImpl::setNodeName(int callId, std::unique_ptr
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -2277,7 +2305,8 @@ DispatchResponse::Status DispatcherImpl::setNodeName(int callId, std::unique_ptr
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setNodeName(in_nodeId, in_name, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2286,10 +2315,10 @@ DispatchResponse::Status DispatcherImpl::setNodeName(int callId, std::unique_ptr
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setNodeValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setNodeValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2302,21 +2331,22 @@ DispatchResponse::Status DispatcherImpl::setNodeValue(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setNodeValue(in_nodeId, in_value);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setOuterHTML(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setOuterHTML(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2329,34 +2359,36 @@ DispatchResponse::Status DispatcherImpl::setOuterHTML(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setOuterHTML(in_nodeId, in_outerHTML);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::undo(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::undo(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->undo();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getFrameOwner(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getFrameOwner(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2366,7 +2398,7 @@ DispatchResponse::Status DispatcherImpl::getFrameOwner(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_nodeId;
@@ -2374,7 +2406,8 @@ DispatchResponse::Status DispatcherImpl::getFrameOwner(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getFrameOwner(in_frameId, &out_nodeId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2383,12 +2416,12 @@ DispatchResponse::Status DispatcherImpl::getFrameOwner(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("DOM", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Debugger.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Debugger.cpp
index b3af5c4fb..e2c51e610 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Debugger.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Debugger.cpp
@@ -851,10 +851,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Debugger.continueToLocation"] = &DispatcherImpl::continueToLocation;
             m_dispatchMap["Debugger.disable"] = &DispatcherImpl::disable;
             m_dispatchMap["Debugger.enable"] = &DispatcherImpl::enable;
@@ -886,67 +885,64 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Debugger.stepOver"] = &DispatcherImpl::stepOver;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status continueToLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status evaluateOnCallFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getPossibleBreakpoints(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getStackTrace(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status pause(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status pauseOnAsyncCall(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status restartFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status resume(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status scheduleStepIntoAsync(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status searchInContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setAsyncCallStackDepth(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBlackboxPatterns(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBlackboxedRanges(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBreakpointByUrl(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBreakpointOnFunctionCall(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBreakpointsActive(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setPauseOnExceptions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setReturnValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setSkipAllPauses(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setVariableValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stepInto(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stepOut(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stepOver(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void continueToLocation(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void evaluateOnCallFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getPossibleBreakpoints(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getScriptSource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getStackTrace(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void pause(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void pauseOnAsyncCall(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeBreakpoint(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void restartFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void resume(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void scheduleStepIntoAsync(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void searchInContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setAsyncCallStackDepth(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBlackboxPatterns(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBlackboxedRanges(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBreakpoint(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBreakpointByUrl(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBreakpointOnFunctionCall(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBreakpointsActive(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setPauseOnExceptions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setReturnValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setScriptSource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setSkipAllPauses(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setVariableValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stepInto(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stepOut(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stepOver(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::continueToLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::continueToLocation(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -962,41 +958,44 @@ DispatchResponse::Status DispatcherImpl::continueToLocation(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->continueToLocation(std::move(in_location), std::move(in_targetCallFrames));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     String out_debuggerId;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable(&out_debuggerId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1005,10 +1004,10 @@ DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<Dict
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::evaluateOnCallFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::evaluateOnCallFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1063,7 +1062,7 @@ DispatchResponse::Status DispatcherImpl::evaluateOnCallFrame(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Runtime::RemoteObject> out_result;
@@ -1072,7 +1071,8 @@ DispatchResponse::Status DispatcherImpl::evaluateOnCallFrame(int callId, std::un
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->evaluateOnCallFrame(in_callFrameId, in_expression, std::move(in_objectGroup), std::move(in_includeCommandLineAPI), std::move(in_silent), std::move(in_returnByValue), std::move(in_generatePreview), std::move(in_throwOnSideEffect), std::move(in_timeout), &out_result, &out_exceptionDetails);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1084,10 +1084,10 @@ DispatchResponse::Status DispatcherImpl::evaluateOnCallFrame(int callId, std::un
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getPossibleBreakpoints(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getPossibleBreakpoints(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1109,7 +1109,7 @@ DispatchResponse::Status DispatcherImpl::getPossibleBreakpoints(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Debugger::BreakLocation>> out_locations;
@@ -1117,7 +1117,8 @@ DispatchResponse::Status DispatcherImpl::getPossibleBreakpoints(int callId, std:
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getPossibleBreakpoints(std::move(in_start), std::move(in_end), std::move(in_restrictToFunction), &out_locations);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1126,10 +1127,10 @@ DispatchResponse::Status DispatcherImpl::getPossibleBreakpoints(int callId, std:
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getScriptSource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1139,7 +1140,7 @@ DispatchResponse::Status DispatcherImpl::getScriptSource(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_scriptSource;
@@ -1147,7 +1148,8 @@ DispatchResponse::Status DispatcherImpl::getScriptSource(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getScriptSource(in_scriptId, &out_scriptSource);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1156,10 +1158,10 @@ DispatchResponse::Status DispatcherImpl::getScriptSource(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getStackTrace(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getStackTrace(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1169,7 +1171,7 @@ DispatchResponse::Status DispatcherImpl::getStackTrace(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Runtime::StackTrace> out_stackTrace;
@@ -1177,7 +1179,8 @@ DispatchResponse::Status DispatcherImpl::getStackTrace(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getStackTrace(std::move(in_stackTraceId), &out_stackTrace);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1186,23 +1189,24 @@ DispatchResponse::Status DispatcherImpl::getStackTrace(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::pause(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::pause(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->pause();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::pauseOnAsyncCall(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::pauseOnAsyncCall(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1212,21 +1216,22 @@ DispatchResponse::Status DispatcherImpl::pauseOnAsyncCall(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->pauseOnAsyncCall(std::move(in_parentStackTraceId));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeBreakpoint(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1236,21 +1241,22 @@ DispatchResponse::Status DispatcherImpl::removeBreakpoint(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeBreakpoint(in_breakpointId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::restartFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::restartFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1260,7 +1266,7 @@ DispatchResponse::Status DispatcherImpl::restartFrame(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>> out_callFrames;
@@ -1270,7 +1276,8 @@ DispatchResponse::Status DispatcherImpl::restartFrame(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->restartFrame(in_callFrameId, &out_callFrames, &out_asyncStackTrace, &out_asyncStackTraceId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1285,26 +1292,27 @@ DispatchResponse::Status DispatcherImpl::restartFrame(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::resume(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::resume(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->resume();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 class ScheduleStepIntoAsyncCallbackImpl : public Backend::ScheduleStepIntoAsyncCallback, public DispatcherBase::Callback {
     public:
-        ScheduleStepIntoAsyncCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        ScheduleStepIntoAsyncCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess() override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -1321,15 +1329,15 @@ class ScheduleStepIntoAsyncCallbackImpl : public Backend::ScheduleStepIntoAsyncC
         }
 };
 
-DispatchResponse::Status DispatcherImpl::scheduleStepIntoAsync(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::scheduleStepIntoAsync(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<ScheduleStepIntoAsyncCallbackImpl> callback(new ScheduleStepIntoAsyncCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<ScheduleStepIntoAsyncCallbackImpl> callback(new ScheduleStepIntoAsyncCallbackImpl(weakPtr(), callId, method, message));
     m_backend->scheduleStepIntoAsync(std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::searchInContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::searchInContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1354,7 +1362,7 @@ DispatchResponse::Status DispatcherImpl::searchInContent(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>> out_result;
@@ -1362,7 +1370,8 @@ DispatchResponse::Status DispatcherImpl::searchInContent(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->searchInContent(in_scriptId, in_query, std::move(in_caseSensitive), std::move(in_isRegex), &out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1371,10 +1380,10 @@ DispatchResponse::Status DispatcherImpl::searchInContent(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setAsyncCallStackDepth(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setAsyncCallStackDepth(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1384,21 +1393,22 @@ DispatchResponse::Status DispatcherImpl::setAsyncCallStackDepth(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setAsyncCallStackDepth(in_maxDepth);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBlackboxPatterns(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBlackboxPatterns(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1408,21 +1418,22 @@ DispatchResponse::Status DispatcherImpl::setBlackboxPatterns(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBlackboxPatterns(std::move(in_patterns));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBlackboxedRanges(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBlackboxedRanges(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1435,21 +1446,22 @@ DispatchResponse::Status DispatcherImpl::setBlackboxedRanges(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBlackboxedRanges(in_scriptId, std::move(in_positions));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBreakpoint(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1465,7 +1477,7 @@ DispatchResponse::Status DispatcherImpl::setBreakpoint(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_breakpointId;
@@ -1474,7 +1486,8 @@ DispatchResponse::Status DispatcherImpl::setBreakpoint(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBreakpoint(std::move(in_location), std::move(in_condition), &out_breakpointId, &out_actualLocation);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1484,10 +1497,10 @@ DispatchResponse::Status DispatcherImpl::setBreakpoint(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBreakpointByUrl(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1527,7 +1540,7 @@ DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_breakpointId;
@@ -1536,7 +1549,8 @@ DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::uni
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBreakpointByUrl(in_lineNumber, std::move(in_url), std::move(in_urlRegex), std::move(in_scriptHash), std::move(in_columnNumber), std::move(in_condition), &out_breakpointId, &out_locations);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1546,10 +1560,10 @@ DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::uni
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBreakpointOnFunctionCall(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBreakpointOnFunctionCall(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1565,7 +1579,7 @@ DispatchResponse::Status DispatcherImpl::setBreakpointOnFunctionCall(int callId,
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_breakpointId;
@@ -1573,7 +1587,8 @@ DispatchResponse::Status DispatcherImpl::setBreakpointOnFunctionCall(int callId,
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBreakpointOnFunctionCall(in_objectId, std::move(in_condition), &out_breakpointId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1582,10 +1597,10 @@ DispatchResponse::Status DispatcherImpl::setBreakpointOnFunctionCall(int callId,
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBreakpointsActive(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBreakpointsActive(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1595,21 +1610,22 @@ DispatchResponse::Status DispatcherImpl::setBreakpointsActive(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBreakpointsActive(in_active);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setPauseOnExceptions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setPauseOnExceptions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1619,21 +1635,22 @@ DispatchResponse::Status DispatcherImpl::setPauseOnExceptions(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setPauseOnExceptions(in_state);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setReturnValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setReturnValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1643,21 +1660,22 @@ DispatchResponse::Status DispatcherImpl::setReturnValue(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setReturnValue(std::move(in_newValue));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setScriptSource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1676,7 +1694,7 @@ DispatchResponse::Status DispatcherImpl::setScriptSource(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<protocol::Array<protocol::Debugger::CallFrame>> out_callFrames;
@@ -1688,7 +1706,8 @@ DispatchResponse::Status DispatcherImpl::setScriptSource(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setScriptSource(in_scriptId, in_scriptSource, std::move(in_dryRun), &out_callFrames, &out_stackChanged, &out_asyncStackTrace, &out_asyncStackTraceId, &out_exceptionDetails);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1711,10 +1730,10 @@ DispatchResponse::Status DispatcherImpl::setScriptSource(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setSkipAllPauses(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setSkipAllPauses(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1724,21 +1743,22 @@ DispatchResponse::Status DispatcherImpl::setSkipAllPauses(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setSkipAllPauses(in_skip);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setVariableValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setVariableValue(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1757,21 +1777,22 @@ DispatchResponse::Status DispatcherImpl::setVariableValue(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setVariableValue(in_scopeNumber, in_variableName, std::move(in_newValue), in_callFrameId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stepInto(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stepInto(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1784,49 +1805,52 @@ DispatchResponse::Status DispatcherImpl::stepInto(int callId, std::unique_ptr<Di
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stepInto(std::move(in_breakOnAsyncCall));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stepOut(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stepOut(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stepOut();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stepOver(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stepOver(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stepOver();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Debugger", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Forward.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Forward.h
index e74099941..687f72ed5 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Forward.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Forward.h
@@ -86,6 +86,7 @@ class  FrontendChannel {
         virtual ~FrontendChannel() { }
         virtual void sendProtocolResponse(int callId, std::unique_ptr<Serializable> message) = 0;
         virtual void sendProtocolNotification(std::unique_ptr<Serializable> message) = 0;
+        virtual void fallThrough(int callId, const String& method, const String& message) = 0;
         virtual void flushProtocolNotifications() = 0;
 };
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/HeapProfiler.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/HeapProfiler.cpp
index 1793f8176..e9d8b5c03 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/HeapProfiler.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/HeapProfiler.cpp
@@ -291,10 +291,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["HeapProfiler.addInspectedHeapObject"] = &DispatcherImpl::addInspectedHeapObject;
             m_dispatchMap["HeapProfiler.collectGarbage"] = &DispatcherImpl::collectGarbage;
             m_dispatchMap["HeapProfiler.disable"] = &DispatcherImpl::disable;
@@ -309,50 +308,47 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["HeapProfiler.takeHeapSnapshot"] = &DispatcherImpl::takeHeapSnapshot;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status addInspectedHeapObject(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status collectGarbage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getHeapObjectId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getObjectByHeapObjectId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getSamplingProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startSampling(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startTrackingHeapObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopSampling(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopTrackingHeapObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status takeHeapSnapshot(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void addInspectedHeapObject(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void collectGarbage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getHeapObjectId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getObjectByHeapObjectId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getSamplingProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startSampling(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startTrackingHeapObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopSampling(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopTrackingHeapObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void takeHeapSnapshot(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::addInspectedHeapObject(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::addInspectedHeapObject(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -362,60 +358,64 @@ DispatchResponse::Status DispatcherImpl::addInspectedHeapObject(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->addInspectedHeapObject(in_heapObjectId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::collectGarbage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::collectGarbage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->collectGarbage();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getHeapObjectId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getHeapObjectId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -425,7 +425,7 @@ DispatchResponse::Status DispatcherImpl::getHeapObjectId(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_heapSnapshotObjectId;
@@ -433,7 +433,8 @@ DispatchResponse::Status DispatcherImpl::getHeapObjectId(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getHeapObjectId(in_objectId, &out_heapSnapshotObjectId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -442,10 +443,10 @@ DispatchResponse::Status DispatcherImpl::getHeapObjectId(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getObjectByHeapObjectId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getObjectByHeapObjectId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -461,7 +462,7 @@ DispatchResponse::Status DispatcherImpl::getObjectByHeapObjectId(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Runtime::RemoteObject> out_result;
@@ -469,7 +470,8 @@ DispatchResponse::Status DispatcherImpl::getObjectByHeapObjectId(int callId, std
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getObjectByHeapObjectId(in_objectId, std::move(in_objectGroup), &out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -478,17 +480,18 @@ DispatchResponse::Status DispatcherImpl::getObjectByHeapObjectId(int callId, std
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getSamplingProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getSamplingProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile> out_profile;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getSamplingProfile(&out_profile);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -497,10 +500,10 @@ DispatchResponse::Status DispatcherImpl::getSamplingProfile(int callId, std::uni
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startSampling(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startSampling(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -513,21 +516,22 @@ DispatchResponse::Status DispatcherImpl::startSampling(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startSampling(std::move(in_samplingInterval));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startTrackingHeapObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startTrackingHeapObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -540,28 +544,30 @@ DispatchResponse::Status DispatcherImpl::startTrackingHeapObjects(int callId, st
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startTrackingHeapObjects(std::move(in_trackAllocations));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopSampling(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopSampling(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile> out_profile;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopSampling(&out_profile);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -570,10 +576,10 @@ DispatchResponse::Status DispatcherImpl::stopSampling(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopTrackingHeapObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopTrackingHeapObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -586,21 +592,22 @@ DispatchResponse::Status DispatcherImpl::stopTrackingHeapObjects(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopTrackingHeapObjects(std::move(in_reportProgress));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::takeHeapSnapshot(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::takeHeapSnapshot(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -613,23 +620,24 @@ DispatchResponse::Status DispatcherImpl::takeHeapSnapshot(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->takeHeapSnapshot(std::move(in_reportProgress));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("HeapProfiler", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Log.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Log.cpp
index 380e247cf..72fffe536 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Log.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Log.cpp
@@ -226,10 +226,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Log.clear"] = &DispatcherImpl::clear;
             m_dispatchMap["Log.disable"] = &DispatcherImpl::disable;
             m_dispatchMap["Log.enable"] = &DispatcherImpl::enable;
@@ -237,82 +236,82 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Log.stopViolationsReport"] = &DispatcherImpl::stopViolationsReport;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status clear(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startViolationsReport(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopViolationsReport(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void clear(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startViolationsReport(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopViolationsReport(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::clear(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::clear(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->clear();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startViolationsReport(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startViolationsReport(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -322,36 +321,38 @@ DispatchResponse::Status DispatcherImpl::startViolationsReport(int callId, std::
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startViolationsReport(std::move(in_config));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopViolationsReport(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopViolationsReport(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopViolationsReport();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Log", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Network.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Network.cpp
index 8954e72b5..bdf581f16 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Network.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Network.cpp
@@ -2055,10 +2055,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Network.canClearBrowserCache"] = &DispatcherImpl::canClearBrowserCache;
             m_dispatchMap["Network.canClearBrowserCookies"] = &DispatcherImpl::canClearBrowserCookies;
             m_dispatchMap["Network.canEmulateNetworkConditions"] = &DispatcherImpl::canEmulateNetworkConditions;
@@ -2088,72 +2087,70 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Network.setUserAgentOverride"] = &DispatcherImpl::setUserAgentOverride;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status canClearBrowserCache(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status canClearBrowserCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status canEmulateNetworkConditions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status clearBrowserCache(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status clearBrowserCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status continueInterceptedRequest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status deleteCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status emulateNetworkConditions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getAllCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getCertificate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getResponseBody(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getRequestPostData(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getResponseBodyForInterception(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status replayXHR(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status searchInResponseBody(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBlockedURLs(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBypassServiceWorker(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setCacheDisabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setCookie(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setDataSizeLimitsForTest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setExtraHTTPHeaders(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setRequestInterception(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setUserAgentOverride(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void canClearBrowserCache(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void canClearBrowserCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void canEmulateNetworkConditions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void clearBrowserCache(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void clearBrowserCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void continueInterceptedRequest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void deleteCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void emulateNetworkConditions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getAllCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getCertificate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getResponseBody(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getRequestPostData(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getResponseBodyForInterception(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void replayXHR(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void searchInResponseBody(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBlockedURLs(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBypassServiceWorker(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setCacheDisabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setCookie(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setDataSizeLimitsForTest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setExtraHTTPHeaders(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setRequestInterception(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setUserAgentOverride(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::canClearBrowserCache(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::canClearBrowserCache(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     bool out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->canClearBrowserCache(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2162,17 +2159,18 @@ DispatchResponse::Status DispatcherImpl::canClearBrowserCache(int callId, std::u
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::canClearBrowserCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::canClearBrowserCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     bool out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->canClearBrowserCookies(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2181,17 +2179,18 @@ DispatchResponse::Status DispatcherImpl::canClearBrowserCookies(int callId, std:
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::canEmulateNetworkConditions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::canEmulateNetworkConditions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     bool out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->canEmulateNetworkConditions(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2200,36 +2199,38 @@ DispatchResponse::Status DispatcherImpl::canEmulateNetworkConditions(int callId,
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::clearBrowserCache(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::clearBrowserCache(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->clearBrowserCache();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::clearBrowserCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::clearBrowserCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->clearBrowserCookies();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::continueInterceptedRequest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::continueInterceptedRequest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2281,21 +2282,22 @@ DispatchResponse::Status DispatcherImpl::continueInterceptedRequest(int callId,
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->continueInterceptedRequest(in_interceptionId, std::move(in_errorReason), std::move(in_rawResponse), std::move(in_url), std::move(in_method), std::move(in_postData), std::move(in_headers), std::move(in_authChallengeResponse));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::deleteCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::deleteCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2323,34 +2325,36 @@ DispatchResponse::Status DispatcherImpl::deleteCookies(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->deleteCookies(in_name, std::move(in_url), std::move(in_domain), std::move(in_path));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::emulateNetworkConditions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::emulateNetworkConditions(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2375,21 +2379,22 @@ DispatchResponse::Status DispatcherImpl::emulateNetworkConditions(int callId, st
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->emulateNetworkConditions(in_offline, in_latency, in_downloadThroughput, in_uploadThroughput, std::move(in_connectionType));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2414,28 +2419,30 @@ DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<Dict
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable(std::move(in_maxTotalBufferSize), std::move(in_maxResourceBufferSize), std::move(in_maxPostDataSize));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getAllCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getAllCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Network::Cookie>> out_cookies;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getAllCookies(&out_cookies);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2444,10 +2451,10 @@ DispatchResponse::Status DispatcherImpl::getAllCookies(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getCertificate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getCertificate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2457,7 +2464,7 @@ DispatchResponse::Status DispatcherImpl::getCertificate(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<String>> out_tableNames;
@@ -2465,7 +2472,8 @@ DispatchResponse::Status DispatcherImpl::getCertificate(int callId, std::unique_
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getCertificate(in_origin, &out_tableNames);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2474,10 +2482,10 @@ DispatchResponse::Status DispatcherImpl::getCertificate(int callId, std::unique_
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2490,7 +2498,7 @@ DispatchResponse::Status DispatcherImpl::getCookies(int callId, std::unique_ptr<
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Network::Cookie>> out_cookies;
@@ -2498,7 +2506,8 @@ DispatchResponse::Status DispatcherImpl::getCookies(int callId, std::unique_ptr<
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getCookies(std::move(in_urls), &out_cookies);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2507,10 +2516,10 @@ DispatchResponse::Status DispatcherImpl::getCookies(int callId, std::unique_ptr<
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getResponseBody(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getResponseBody(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2520,7 +2529,7 @@ DispatchResponse::Status DispatcherImpl::getResponseBody(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_body;
@@ -2529,7 +2538,8 @@ DispatchResponse::Status DispatcherImpl::getResponseBody(int callId, std::unique
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getResponseBody(in_requestId, &out_body, &out_base64Encoded);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2539,10 +2549,10 @@ DispatchResponse::Status DispatcherImpl::getResponseBody(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getRequestPostData(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getRequestPostData(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2552,7 +2562,7 @@ DispatchResponse::Status DispatcherImpl::getRequestPostData(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_postData;
@@ -2560,7 +2570,8 @@ DispatchResponse::Status DispatcherImpl::getRequestPostData(int callId, std::uni
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getRequestPostData(in_requestId, &out_postData);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2569,10 +2580,10 @@ DispatchResponse::Status DispatcherImpl::getRequestPostData(int callId, std::uni
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getResponseBodyForInterception(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getResponseBodyForInterception(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2582,7 +2593,7 @@ DispatchResponse::Status DispatcherImpl::getResponseBodyForInterception(int call
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_body;
@@ -2591,7 +2602,8 @@ DispatchResponse::Status DispatcherImpl::getResponseBodyForInterception(int call
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getResponseBodyForInterception(in_interceptionId, &out_body, &out_base64Encoded);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2601,10 +2613,10 @@ DispatchResponse::Status DispatcherImpl::getResponseBodyForInterception(int call
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::replayXHR(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::replayXHR(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2614,21 +2626,22 @@ DispatchResponse::Status DispatcherImpl::replayXHR(int callId, std::unique_ptr<D
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->replayXHR(in_requestId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::searchInResponseBody(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::searchInResponseBody(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2653,7 +2666,7 @@ DispatchResponse::Status DispatcherImpl::searchInResponseBody(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>> out_result;
@@ -2661,7 +2674,8 @@ DispatchResponse::Status DispatcherImpl::searchInResponseBody(int callId, std::u
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->searchInResponseBody(in_requestId, in_query, std::move(in_caseSensitive), std::move(in_isRegex), &out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2670,10 +2684,10 @@ DispatchResponse::Status DispatcherImpl::searchInResponseBody(int callId, std::u
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBlockedURLs(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBlockedURLs(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2683,21 +2697,22 @@ DispatchResponse::Status DispatcherImpl::setBlockedURLs(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBlockedURLs(std::move(in_urls));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBypassServiceWorker(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBypassServiceWorker(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2707,21 +2722,22 @@ DispatchResponse::Status DispatcherImpl::setBypassServiceWorker(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBypassServiceWorker(in_bypass);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setCacheDisabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setCacheDisabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2731,21 +2747,22 @@ DispatchResponse::Status DispatcherImpl::setCacheDisabled(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setCacheDisabled(in_cacheDisabled);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setCookie(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setCookie(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2800,7 +2817,7 @@ DispatchResponse::Status DispatcherImpl::setCookie(int callId, std::unique_ptr<D
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     bool out_success;
@@ -2808,7 +2825,8 @@ DispatchResponse::Status DispatcherImpl::setCookie(int callId, std::unique_ptr<D
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setCookie(in_name, in_value, std::move(in_url), std::move(in_domain), std::move(in_path), std::move(in_secure), std::move(in_httpOnly), std::move(in_sameSite), std::move(in_expires), &out_success);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2817,10 +2835,10 @@ DispatchResponse::Status DispatcherImpl::setCookie(int callId, std::unique_ptr<D
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setCookies(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setCookies(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2830,21 +2848,22 @@ DispatchResponse::Status DispatcherImpl::setCookies(int callId, std::unique_ptr<
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setCookies(std::move(in_cookies));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setDataSizeLimitsForTest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setDataSizeLimitsForTest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2857,21 +2876,22 @@ DispatchResponse::Status DispatcherImpl::setDataSizeLimitsForTest(int callId, st
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setDataSizeLimitsForTest(in_maxTotalSize, in_maxResourceSize);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setExtraHTTPHeaders(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setExtraHTTPHeaders(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2881,21 +2901,22 @@ DispatchResponse::Status DispatcherImpl::setExtraHTTPHeaders(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setExtraHTTPHeaders(std::move(in_headers));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setRequestInterception(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setRequestInterception(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2905,21 +2926,22 @@ DispatchResponse::Status DispatcherImpl::setRequestInterception(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setRequestInterception(std::move(in_patterns));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setUserAgentOverride(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setUserAgentOverride(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2929,23 +2951,24 @@ DispatchResponse::Status DispatcherImpl::setUserAgentOverride(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setUserAgentOverride(in_userAgent);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Network", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Overlay.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Overlay.cpp
index 9377e5568..9388881cf 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Overlay.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Overlay.cpp
@@ -291,10 +291,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Overlay.disable"] = &DispatcherImpl::disable;
             m_dispatchMap["Overlay.enable"] = &DispatcherImpl::enable;
             m_dispatchMap["Overlay.getHighlightObjectForTest"] = &DispatcherImpl::getHighlightObjectForTest;
@@ -313,80 +312,79 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Overlay.setSuspended"] = &DispatcherImpl::setSuspended;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getHighlightObjectForTest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status hideHighlight(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status highlightFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status highlightNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status highlightQuad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status highlightRect(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setInspectMode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setPausedInDebuggerMessage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setShowDebugBorders(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setShowFPSCounter(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setShowPaintRects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setShowScrollBottleneckRects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setShowViewportSizeOnResize(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setSuspended(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getHighlightObjectForTest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void hideHighlight(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void highlightFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void highlightNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void highlightQuad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void highlightRect(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setInspectMode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setPausedInDebuggerMessage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setShowDebugBorders(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setShowFPSCounter(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setShowPaintRects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setShowScrollBottleneckRects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setShowViewportSizeOnResize(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setSuspended(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getHighlightObjectForTest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getHighlightObjectForTest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -396,7 +394,7 @@ DispatchResponse::Status DispatcherImpl::getHighlightObjectForTest(int callId, s
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::DictionaryValue> out_highlight;
@@ -404,7 +402,8 @@ DispatchResponse::Status DispatcherImpl::getHighlightObjectForTest(int callId, s
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getHighlightObjectForTest(in_nodeId, &out_highlight);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -413,23 +412,24 @@ DispatchResponse::Status DispatcherImpl::getHighlightObjectForTest(int callId, s
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::hideHighlight(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::hideHighlight(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->hideHighlight();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::highlightFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::highlightFrame(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -451,21 +451,22 @@ DispatchResponse::Status DispatcherImpl::highlightFrame(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->highlightFrame(in_frameId, std::move(in_contentColor), std::move(in_contentOutlineColor));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::highlightNode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::highlightNode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -493,21 +494,22 @@ DispatchResponse::Status DispatcherImpl::highlightNode(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->highlightNode(std::move(in_highlightConfig), std::move(in_nodeId), std::move(in_backendNodeId), std::move(in_objectId));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::highlightQuad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::highlightQuad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -529,21 +531,22 @@ DispatchResponse::Status DispatcherImpl::highlightQuad(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->highlightQuad(std::move(in_quad), std::move(in_color), std::move(in_outlineColor));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::highlightRect(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::highlightRect(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -574,21 +577,22 @@ DispatchResponse::Status DispatcherImpl::highlightRect(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->highlightRect(in_x, in_y, in_width, in_height, std::move(in_color), std::move(in_outlineColor));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setInspectMode(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setInspectMode(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -604,21 +608,22 @@ DispatchResponse::Status DispatcherImpl::setInspectMode(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setInspectMode(in_mode, std::move(in_highlightConfig));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setPausedInDebuggerMessage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setPausedInDebuggerMessage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -631,21 +636,22 @@ DispatchResponse::Status DispatcherImpl::setPausedInDebuggerMessage(int callId,
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setPausedInDebuggerMessage(std::move(in_message));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setShowDebugBorders(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setShowDebugBorders(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -655,21 +661,22 @@ DispatchResponse::Status DispatcherImpl::setShowDebugBorders(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setShowDebugBorders(in_show);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setShowFPSCounter(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setShowFPSCounter(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -679,21 +686,22 @@ DispatchResponse::Status DispatcherImpl::setShowFPSCounter(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setShowFPSCounter(in_show);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setShowPaintRects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setShowPaintRects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -703,21 +711,22 @@ DispatchResponse::Status DispatcherImpl::setShowPaintRects(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setShowPaintRects(in_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setShowScrollBottleneckRects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setShowScrollBottleneckRects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -727,21 +736,22 @@ DispatchResponse::Status DispatcherImpl::setShowScrollBottleneckRects(int callId
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setShowScrollBottleneckRects(in_show);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setShowViewportSizeOnResize(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setShowViewportSizeOnResize(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -751,21 +761,22 @@ DispatchResponse::Status DispatcherImpl::setShowViewportSizeOnResize(int callId,
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setShowViewportSizeOnResize(in_show);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setSuspended(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setSuspended(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -775,23 +786,24 @@ DispatchResponse::Status DispatcherImpl::setSuspended(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setSuspended(in_suspended);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Overlay", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Page.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Page.cpp
index 6d3d86e5d..9a8c64a3d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Page.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Page.cpp
@@ -1398,10 +1398,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Page.addScriptToEvaluateOnLoad"] = &DispatcherImpl::addScriptToEvaluateOnLoad;
             m_dispatchMap["Page.addScriptToEvaluateOnNewDocument"] = &DispatcherImpl::addScriptToEvaluateOnNewDocument;
             m_dispatchMap["Page.bringToFront"] = &DispatcherImpl::bringToFront;
@@ -1445,70 +1444,67 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Page.stopScreencast"] = &DispatcherImpl::stopScreencast;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status addScriptToEvaluateOnLoad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status addScriptToEvaluateOnNewDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status bringToFront(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status captureScreenshot(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status createIsolatedWorld(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getAppManifest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getFrameTree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getLayoutMetrics(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getNavigationHistory(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getResourceContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getResourceTree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status handleJavaScriptDialog(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status navigate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status navigateToHistoryEntry(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status printToPDF(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status reload(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeScriptToEvaluateOnLoad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeScriptToEvaluateOnNewDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status requestAppBanner(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status screencastFrameAck(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status searchInResource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setAdBlockingEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setBypassCSP(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setDocumentContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setDownloadBehavior(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setLifecycleEventsEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startScreencast(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopLoading(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status crash(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopScreencast(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void addScriptToEvaluateOnLoad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void addScriptToEvaluateOnNewDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void bringToFront(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void captureScreenshot(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void createIsolatedWorld(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getAppManifest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getFrameTree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getLayoutMetrics(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getNavigationHistory(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getResourceContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getResourceTree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void handleJavaScriptDialog(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void navigate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void navigateToHistoryEntry(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void printToPDF(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void reload(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeScriptToEvaluateOnLoad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeScriptToEvaluateOnNewDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void requestAppBanner(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void screencastFrameAck(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void searchInResource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setAdBlockingEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setBypassCSP(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setDocumentContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setDownloadBehavior(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setLifecycleEventsEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startScreencast(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopLoading(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void crash(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopScreencast(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnLoad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::addScriptToEvaluateOnLoad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1518,7 +1514,7 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnLoad(int callId, s
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_identifier;
@@ -1526,7 +1522,8 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnLoad(int callId, s
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->addScriptToEvaluateOnLoad(in_scriptSource, &out_identifier);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1535,10 +1532,10 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnLoad(int callId, s
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnNewDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::addScriptToEvaluateOnNewDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1548,7 +1545,7 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnNewDocument(int ca
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_identifier;
@@ -1556,7 +1553,8 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnNewDocument(int ca
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->addScriptToEvaluateOnNewDocument(in_source, &out_identifier);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1565,23 +1563,24 @@ DispatchResponse::Status DispatcherImpl::addScriptToEvaluateOnNewDocument(int ca
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::bringToFront(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::bringToFront(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->bringToFront();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::captureScreenshot(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::captureScreenshot(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1612,7 +1611,7 @@ DispatchResponse::Status DispatcherImpl::captureScreenshot(int callId, std::uniq
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_data;
@@ -1620,7 +1619,8 @@ DispatchResponse::Status DispatcherImpl::captureScreenshot(int callId, std::uniq
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->captureScreenshot(std::move(in_format), std::move(in_quality), std::move(in_clip), std::move(in_fromSurface), &out_data);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1629,10 +1629,10 @@ DispatchResponse::Status DispatcherImpl::captureScreenshot(int callId, std::uniq
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::createIsolatedWorld(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::createIsolatedWorld(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1654,7 +1654,7 @@ DispatchResponse::Status DispatcherImpl::createIsolatedWorld(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     int out_executionContextId;
@@ -1662,7 +1662,8 @@ DispatchResponse::Status DispatcherImpl::createIsolatedWorld(int callId, std::un
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->createIsolatedWorld(in_frameId, std::move(in_worldName), std::move(in_grantUniveralAccess), &out_executionContextId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1671,36 +1672,38 @@ DispatchResponse::Status DispatcherImpl::createIsolatedWorld(int callId, std::un
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getAppManifest(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getAppManifest(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     String out_url;
     std::unique_ptr<protocol::Array<protocol::Page::AppManifestError>> out_errors;
@@ -1709,7 +1712,8 @@ DispatchResponse::Status DispatcherImpl::getAppManifest(int callId, std::unique_
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getAppManifest(&out_url, &out_errors, &out_data);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1722,17 +1726,18 @@ DispatchResponse::Status DispatcherImpl::getAppManifest(int callId, std::unique_
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getFrameTree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getFrameTree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Page::FrameTree> out_frameTree;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getFrameTree(&out_frameTree);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1741,10 +1746,10 @@ DispatchResponse::Status DispatcherImpl::getFrameTree(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getLayoutMetrics(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getLayoutMetrics(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Page::LayoutViewport> out_layoutViewport;
     std::unique_ptr<protocol::Page::VisualViewport> out_visualViewport;
@@ -1753,7 +1758,8 @@ DispatchResponse::Status DispatcherImpl::getLayoutMetrics(int callId, std::uniqu
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getLayoutMetrics(&out_layoutViewport, &out_visualViewport, &out_contentSize);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1764,10 +1770,10 @@ DispatchResponse::Status DispatcherImpl::getLayoutMetrics(int callId, std::uniqu
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getNavigationHistory(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getNavigationHistory(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     int out_currentIndex;
     std::unique_ptr<protocol::Array<protocol::Page::NavigationEntry>> out_entries;
@@ -1775,7 +1781,8 @@ DispatchResponse::Status DispatcherImpl::getNavigationHistory(int callId, std::u
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getNavigationHistory(&out_currentIndex, &out_entries);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1785,10 +1792,10 @@ DispatchResponse::Status DispatcherImpl::getNavigationHistory(int callId, std::u
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getResourceContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getResourceContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1801,7 +1808,7 @@ DispatchResponse::Status DispatcherImpl::getResourceContent(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_content;
@@ -1810,7 +1817,8 @@ DispatchResponse::Status DispatcherImpl::getResourceContent(int callId, std::uni
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getResourceContent(in_frameId, in_url, &out_content, &out_base64Encoded);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1820,17 +1828,18 @@ DispatchResponse::Status DispatcherImpl::getResourceContent(int callId, std::uni
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getResourceTree(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getResourceTree(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Page::FrameResourceTree> out_frameTree;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getResourceTree(&out_frameTree);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1839,10 +1848,10 @@ DispatchResponse::Status DispatcherImpl::getResourceTree(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::handleJavaScriptDialog(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::handleJavaScriptDialog(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1858,21 +1867,22 @@ DispatchResponse::Status DispatcherImpl::handleJavaScriptDialog(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->handleJavaScriptDialog(in_accept, std::move(in_promptText));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::navigate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::navigate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1900,7 +1910,7 @@ DispatchResponse::Status DispatcherImpl::navigate(int callId, std::unique_ptr<Di
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_frameId;
@@ -1910,7 +1920,8 @@ DispatchResponse::Status DispatcherImpl::navigate(int callId, std::unique_ptr<Di
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->navigate(in_url, std::move(in_referrer), std::move(in_transitionType), std::move(in_frameId), &out_frameId, &out_loaderId, &out_errorText);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1925,10 +1936,10 @@ DispatchResponse::Status DispatcherImpl::navigate(int callId, std::unique_ptr<Di
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::navigateToHistoryEntry(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::navigateToHistoryEntry(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1938,21 +1949,22 @@ DispatchResponse::Status DispatcherImpl::navigateToHistoryEntry(int callId, std:
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->navigateToHistoryEntry(in_entryId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::printToPDF(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::printToPDF(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2049,7 +2061,7 @@ DispatchResponse::Status DispatcherImpl::printToPDF(int callId, std::unique_ptr<
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     String out_data;
@@ -2057,7 +2069,8 @@ DispatchResponse::Status DispatcherImpl::printToPDF(int callId, std::unique_ptr<
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->printToPDF(std::move(in_landscape), std::move(in_displayHeaderFooter), std::move(in_printBackground), std::move(in_scale), std::move(in_paperWidth), std::move(in_paperHeight), std::move(in_marginTop), std::move(in_marginBottom), std::move(in_marginLeft), std::move(in_marginRight), std::move(in_pageRanges), std::move(in_ignoreInvalidPageRanges), std::move(in_headerTemplate), std::move(in_footerTemplate), std::move(in_preferCSSPageSize), &out_data);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2066,10 +2079,10 @@ DispatchResponse::Status DispatcherImpl::printToPDF(int callId, std::unique_ptr<
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::reload(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::reload(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2088,21 +2101,22 @@ DispatchResponse::Status DispatcherImpl::reload(int callId, std::unique_ptr<Dict
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->reload(std::move(in_ignoreCache), std::move(in_scriptToEvaluateOnLoad));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeScriptToEvaluateOnLoad(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeScriptToEvaluateOnLoad(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2112,21 +2126,22 @@ DispatchResponse::Status DispatcherImpl::removeScriptToEvaluateOnLoad(int callId
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeScriptToEvaluateOnLoad(in_identifier);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeScriptToEvaluateOnNewDocument(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeScriptToEvaluateOnNewDocument(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2136,34 +2151,36 @@ DispatchResponse::Status DispatcherImpl::removeScriptToEvaluateOnNewDocument(int
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeScriptToEvaluateOnNewDocument(in_identifier);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::requestAppBanner(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::requestAppBanner(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->requestAppBanner();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::screencastFrameAck(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::screencastFrameAck(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2173,21 +2190,22 @@ DispatchResponse::Status DispatcherImpl::screencastFrameAck(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->screencastFrameAck(in_sessionId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::searchInResource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::searchInResource(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2215,7 +2233,7 @@ DispatchResponse::Status DispatcherImpl::searchInResource(int callId, std::uniqu
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>> out_result;
@@ -2223,7 +2241,8 @@ DispatchResponse::Status DispatcherImpl::searchInResource(int callId, std::uniqu
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->searchInResource(in_frameId, in_url, in_query, std::move(in_caseSensitive), std::move(in_isRegex), &out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -2232,10 +2251,10 @@ DispatchResponse::Status DispatcherImpl::searchInResource(int callId, std::uniqu
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setAdBlockingEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setAdBlockingEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2245,21 +2264,22 @@ DispatchResponse::Status DispatcherImpl::setAdBlockingEnabled(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setAdBlockingEnabled(in_enabled);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setBypassCSP(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setBypassCSP(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2269,21 +2289,22 @@ DispatchResponse::Status DispatcherImpl::setBypassCSP(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setBypassCSP(in_enabled);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setDocumentContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setDocumentContent(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2296,21 +2317,22 @@ DispatchResponse::Status DispatcherImpl::setDocumentContent(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setDocumentContent(in_frameId, in_html);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setDownloadBehavior(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setDownloadBehavior(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2326,21 +2348,22 @@ DispatchResponse::Status DispatcherImpl::setDownloadBehavior(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setDownloadBehavior(in_behavior, std::move(in_downloadPath));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setLifecycleEventsEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setLifecycleEventsEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2350,21 +2373,22 @@ DispatchResponse::Status DispatcherImpl::setLifecycleEventsEnabled(int callId, s
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setLifecycleEventsEnabled(in_enabled);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startScreencast(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startScreencast(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2401,62 +2425,66 @@ DispatchResponse::Status DispatcherImpl::startScreencast(int callId, std::unique
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startScreencast(std::move(in_format), std::move(in_quality), std::move(in_maxWidth), std::move(in_maxHeight), std::move(in_everyNthFrame));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopLoading(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopLoading(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopLoading();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::crash(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::crash(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->crash();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopScreencast(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopScreencast(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopScreencast();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Page", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Profiler.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Profiler.cpp
index ffcd698ac..3dd090ed3 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Profiler.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Profiler.cpp
@@ -522,10 +522,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Profiler.disable"] = &DispatcherImpl::disable;
             m_dispatchMap["Profiler.enable"] = &DispatcherImpl::enable;
             m_dispatchMap["Profiler.getBestEffortCoverage"] = &DispatcherImpl::getBestEffortCoverage;
@@ -540,83 +539,83 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Profiler.takeTypeProfile"] = &DispatcherImpl::takeTypeProfile;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getBestEffortCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setSamplingInterval(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status start(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startPreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status startTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stop(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopPreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status stopTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status takePreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status takeTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getBestEffortCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setSamplingInterval(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void start(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startPreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void startTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stop(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopPreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void stopTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void takePreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void takeTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getBestEffortCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getBestEffortCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>> out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getBestEffortCoverage(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -625,10 +624,10 @@ DispatchResponse::Status DispatcherImpl::getBestEffortCoverage(int callId, std::
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setSamplingInterval(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setSamplingInterval(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -638,34 +637,36 @@ DispatchResponse::Status DispatcherImpl::setSamplingInterval(int callId, std::un
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setSamplingInterval(in_interval);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::start(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::start(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->start();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startPreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startPreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -684,41 +685,44 @@ DispatchResponse::Status DispatcherImpl::startPreciseCoverage(int callId, std::u
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startPreciseCoverage(std::move(in_callCount), std::move(in_detailed));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::startTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::startTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->startTypeProfile();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stop(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stop(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Profiler::Profile> out_profile;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stop(&out_profile);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -727,43 +731,46 @@ DispatchResponse::Status DispatcherImpl::stop(int callId, std::unique_ptr<Dictio
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopPreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopPreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopPreciseCoverage();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::stopTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::stopTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->stopTypeProfile();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::takePreciseCoverage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::takePreciseCoverage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>> out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->takePreciseCoverage(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -772,17 +779,18 @@ DispatchResponse::Status DispatcherImpl::takePreciseCoverage(int callId, std::un
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::takeTypeProfile(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::takeTypeProfile(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>> out_result;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->takeTypeProfile(&out_result);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -791,12 +799,12 @@ DispatchResponse::Status DispatcherImpl::takeTypeProfile(int callId, std::unique
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Profiler", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.cpp
index 182c147a5..fdd508a27 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.cpp
@@ -561,10 +561,11 @@ DispatcherBase::WeakPtr::~WeakPtr() {
     }
 }
 
-DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
+DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
     : m_backendImpl(std::move(backendImpl))
     , m_callId(callId)
-    , m_callbackId(callbackId) { }
+    , m_method(method)
+    , m_message(message) { }
 
 DispatcherBase::Callback::~Callback() = default;
 
@@ -584,29 +585,17 @@ void DispatcherBase::Callback::fallThroughIfActive() {
     if (!m_backendImpl || !m_backendImpl->get()) {
         return;
     }
-    m_backendImpl->get()->markFallThrough(m_callbackId);
+    m_backendImpl->get()->channel()->fallThrough(m_callId, m_method, m_message);
     m_backendImpl = nullptr;
 }
 
 DispatcherBase::DispatcherBase(FrontendChannel* frontendChannel)
-    : m_frontendChannel(frontendChannel)
-    , m_lastCallbackId(0)
-    , m_lastCallbackFallThrough(false) { }
+    : m_frontendChannel(frontendChannel) { }
 
 DispatcherBase::~DispatcherBase() {
     clearFrontend();
 }
 
-int DispatcherBase::nextCallbackId() {
-    m_lastCallbackFallThrough = false;
-    return ++m_lastCallbackId;
-}
-
-void DispatcherBase::markFallThrough(int callbackId) {
-    DCHECK(callbackId == m_lastCallbackId);
-    m_lastCallbackFallThrough = true;
-}
-
 void DispatcherBase::sendResponse(int callId, const DispatchResponse& response, std::unique_ptr<protocol::DictionaryValue> result) {
     if (!m_frontendChannel) {
         return;
@@ -703,12 +692,7 @@ std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr() {
 }
 
 UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
-    : m_frontendChannel(frontendChannel)
-    , m_fallThroughForNotFound(false) { }
-
-void UberDispatcher::setFallThroughForNotFound(bool fallThroughForNotFound) {
-    m_fallThroughForNotFound = fallThroughForNotFound;
-}
+    : m_frontendChannel(frontendChannel) { }
 
 void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase> dispatcher) {
     m_dispatchers[name] = std::move(dispatcher);
@@ -720,84 +704,74 @@ void UberDispatcher::setupRedirects(const std::unordered_map<String, String>& re
     }
 }
 
-DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedMessage, int* outCallId, String* outMethod) {
+bool UberDispatcher::parseCommand(Value* parsedMessage, int* outCallId, String* outMethod) {
     if (!parsedMessage) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
-        return DispatchResponse::kError;
+        return false;
     }
-    std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
+    protocol::DictionaryValue* messageObject = DictionaryValue::cast(parsedMessage);
     if (!messageObject) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must be an object");
-        return DispatchResponse::kError;
+        return false;
     }
 
     int callId = 0;
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue && callIdValue->asInteger(&callId);
-    if (outCallId) {
-        *outCallId = callId;
-    }
     if (!success) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must have integer 'id' property");
-        return DispatchResponse::kError;
+        return false;
+    }
+    if (outCallId) {
+        *outCallId = callId;
     }
 
     protocol::Value* methodValue = messageObject->get("method");
     String method;
     success = methodValue && methodValue->asString(&method);
-    if (outMethod) {
-        *outMethod = method;
-    }
     if (!success) {
         reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kInvalidRequest, "Message must have string 'method' property", nullptr);
-        return DispatchResponse::kError;
+        return false;
     }
 
     std::unordered_map<String, String>::iterator redirectIt = m_redirects.find(method);
     if (redirectIt != m_redirects.end()) {
         method = redirectIt->second;
     }
+    if (outMethod) {
+        *outMethod = method;
+    }
+    return true;
+}
 
+protocol::DispatcherBase* UberDispatcher::findDispatcher(const String& method) {
     size_t dotIndex = StringUtil::find(method, ".");
     if (dotIndex == StringUtil::kNotFound) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
+        return nullptr;
     }
     String domain = StringUtil::substring(method, 0, dotIndex);
     auto it = m_dispatchers.find(domain);
     if (it == m_dispatchers.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
+        return nullptr;
     }
-    return it->second->dispatch(callId, method, std::move(messageObject));
-}
-
-bool UberDispatcher::getCommandName(const String& message, String* method, std::unique_ptr<protocol::DictionaryValue>* parsedMessage) {
-    std::unique_ptr<protocol::Value> value = StringUtil::parseJSON(message);
-    if (!value) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
-        return false;
+    if (!it->second->canDispatch(method)) {
+        return nullptr;
     }
+    return it->second.get();
+}
 
-    protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
-    if (!object) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must be an object");
-        return false;
-    }
+bool UberDispatcher::canDispatch(const String& method) {
+    return !!findDispatcher(method);
+}
 
-    if (!object->getString("method", method)) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must have string 'method' property");
-        return false;
+void UberDispatcher::dispatch(int callId, const String& method, std::unique_ptr<Value> parsedMessage, const String& rawMessage) {
+    protocol::DispatcherBase* dispatcher = findDispatcher(method);
+    if (!dispatcher) {
+        reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
+        return;
     }
-
-    parsedMessage->reset(DictionaryValue::cast(value.release()));
-    return true;
+    std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
+    dispatcher->dispatch(callId, method, rawMessage, std::move(messageObject));
 }
 
 UberDispatcher::~UberDispatcher() = default;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.h
index 5ad51784a..ce807d3c6 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Protocol.h
@@ -476,6 +476,41 @@ struct ValueConversions<ListValue> {
 #ifndef v8_inspector_protocol_Maybe_h
 #define v8_inspector_protocol_Maybe_h
 
+// This macro allows to test for the version of the GNU C++ compiler.
+// Note that this also applies to compilers that masquerade as GCC,
+// for example clang and the Intel C++ compiler for Linux.
+// Use like:
+//  #if IP_GNUC_PREREQ(4, 3, 1)
+//   ...
+//  #endif
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#define IP_GNUC_PREREQ(major, minor, patchlevel)                      \
+  ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= \
+   ((major)*10000 + (minor)*100 + (patchlevel)))
+#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
+#define IP_GNUC_PREREQ(major, minor, patchlevel) \
+  ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >=  \
+   ((major)*10000 + (minor)*100 + (patchlevel)))
+#else
+#define IP_GNUC_PREREQ(major, minor, patchlevel) 0
+#endif
+
+#if defined(__mips64)
+#define IP_TARGET_ARCH_MIPS64 1
+#elif defined(__MIPSEB__) || defined(__MIPSEL__)
+#define IP_TARGET_ARCH_MIPS 1
+#endif
+
+// Allowing the use of noexcept by removing the keyword on older compilers that
+// do not support adding noexcept to default members.
+#if ((IP_GNUC_PREREQ(4, 9, 0) && !defined(IP_TARGET_ARCH_MIPS) && \
+      !defined(IP_TARGET_ARCH_MIPS64)) ||                         \
+     (defined(__clang__) && __cplusplus > 201300L))
+#define IP_NOEXCEPT noexcept
+#else
+#define IP_NOEXCEPT
+#endif
+
 //#include "Forward.h"
 
 namespace v8_inspector {
@@ -486,7 +521,8 @@ class Maybe {
     public:
         Maybe() : m_value() { }
         Maybe(std::unique_ptr<T> value) : m_value(std::move(value)) { }
-        Maybe(Maybe&& other) : m_value(std::move(other.m_value)) { }
+    Maybe(Maybe&& other) IP_NOEXCEPT :
+        m_value(std::move(other.m_value)) {}
         void operator=(std::unique_ptr<T> value) {
             m_value = std::move(value);
         }
@@ -513,7 +549,10 @@ class MaybeBase {
     public:
         MaybeBase() : m_isJust(false) { }
         MaybeBase(T value) : m_isJust(true), m_value(value) { }
-        MaybeBase(MaybeBase&& other) : m_isJust(other.m_isJust), m_value(std::move(other.m_value)) { }
+        MaybeBase(MaybeBase&& other) IP_NOEXCEPT
+    :
+        m_isJust(other.m_isJust),
+        m_value(std::move(other.m_value)) {}
         void operator=(T value) {
             m_value = value;
             m_isJust = true;
@@ -543,7 +582,8 @@ class Maybe<bool> : public MaybeBase<bool> {
     public:
         Maybe() { }
         Maybe(bool value) : MaybeBase(value) { }
-        Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
+    Maybe(Maybe&& other) IP_NOEXCEPT :
+        MaybeBase(std::move(other)) {}
         using MaybeBase::operator=;
 };
 
@@ -552,7 +592,8 @@ class Maybe<int> : public MaybeBase<int> {
     public:
         Maybe() { }
         Maybe(int value) : MaybeBase(value) { }
-        Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
+    Maybe(Maybe&& other) IP_NOEXCEPT :
+        MaybeBase(std::move(other)) {}
         using MaybeBase::operator=;
 };
 
@@ -561,7 +602,8 @@ class Maybe<double> : public MaybeBase<double> {
     public:
         Maybe() { }
         Maybe(double value) : MaybeBase(value) { }
-        Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
+    Maybe(Maybe&& other) IP_NOEXCEPT :
+        MaybeBase(std::move(other)) {}
         using MaybeBase::operator=;
 };
 
@@ -570,13 +612,19 @@ class Maybe<String> : public MaybeBase<String> {
     public:
         Maybe() { }
         Maybe(const String& value) : MaybeBase(value) { }
-        Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
+    Maybe(Maybe&& other) IP_NOEXCEPT :
+        MaybeBase(std::move(other)) {}
         using MaybeBase::operator=;
 };
 
 } // namespace v8_inspector
 } // namespace protocol
 
+#undef IP_GNUC_PREREQ
+#undef IP_TARGET_ARCH_MIPS64
+#undef IP_TARGET_ARCH_MIPS
+#undef IP_NOEXCEPT
+
 #endif // !defined(v8_inspector_protocol_Maybe_h)
 
 
@@ -730,7 +778,6 @@ class  DispatchResponse {
             kSuccess = 0,
             kError = 1,
             kFallThrough = 2,
-            kAsync = 3
         };
 
         enum ErrorCode {
@@ -788,7 +835,7 @@ class  DispatcherBase {
 
         class  Callback {
             public:
-                Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, int callbackId);
+                Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, const String& method, const String& message);
                 virtual ~Callback();
                 void dispose();
 
@@ -799,13 +846,18 @@ class  DispatcherBase {
             private:
                 std::unique_ptr<WeakPtr> m_backendImpl;
                 int m_callId;
-                int m_callbackId;
+                String m_method;
+                String m_message;
         };
 
         explicit DispatcherBase(FrontendChannel*);
         virtual ~DispatcherBase();
 
-        virtual DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
+        virtual bool canDispatch(const String& method) = 0;
+        virtual void dispatch(int callId, const String& method, const String& rawMessage, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
+        FrontendChannel* channel() {
+            return m_frontendChannel;
+        }
 
         void sendResponse(int callId, const DispatchResponse&, std::unique_ptr<protocol::DictionaryValue> result);
         void sendResponse(int callId, const DispatchResponse&);
@@ -815,17 +867,9 @@ class  DispatcherBase {
 
         std::unique_ptr<WeakPtr> weakPtr();
 
-        int nextCallbackId();
-        void markFallThrough(int callbackId);
-        bool lastCallbackFallThrough() {
-            return m_lastCallbackFallThrough;
-        }
-
     private:
         FrontendChannel* m_frontendChannel;
         std::unordered_set<WeakPtr*> m_weakPtrs;
-        int m_lastCallbackId;
-        bool m_lastCallbackFallThrough;
 };
 
 class  UberDispatcher {
@@ -834,20 +878,17 @@ class  UberDispatcher {
         explicit UberDispatcher(FrontendChannel*);
         void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
         void setupRedirects(const std::unordered_map<String, String>&);
-        DispatchResponse::Status dispatch(std::unique_ptr<Value> message, int* callId = nullptr, String* method = nullptr);
+        bool parseCommand(Value* message, int* callId, String* method);
+        bool canDispatch(const String& method);
+        void dispatch(int callId, const String& method, std::unique_ptr<Value> message, const String& rawMessage);
         FrontendChannel* channel() {
             return m_frontendChannel;
         }
-        bool fallThroughForNotFound() {
-            return m_fallThroughForNotFound;
-        }
-        void setFallThroughForNotFound(bool);
-        bool getCommandName(const String& message, String* method, std::unique_ptr<protocol::DictionaryValue>* parsedMessage);
         virtual ~UberDispatcher();
 
     private:
+        protocol::DispatcherBase* findDispatcher(const String& method);
         FrontendChannel* m_frontendChannel;
-        bool m_fallThroughForNotFound;
         std::unordered_map<String, String> m_redirects;
         std::unordered_map<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
 };
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Runtime.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Runtime.cpp
index 25a49b012..cced74815 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Runtime.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Runtime.cpp
@@ -1291,10 +1291,9 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Runtime.awaitPromise"] = &DispatcherImpl::awaitPromise;
             m_dispatchMap["Runtime.callFunctionOn"] = &DispatcherImpl::callFunctionOn;
             m_dispatchMap["Runtime.compileScript"] = &DispatcherImpl::compileScript;
@@ -1319,62 +1318,59 @@ class DispatcherImpl : public protocol::DispatcherBase {
             m_dispatchMap["Runtime.removeBinding"] = &DispatcherImpl::removeBinding;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status awaitPromise(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status callFunctionOn(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status compileScript(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status discardConsoleEntries(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status evaluate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getIsolateId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getHeapUsage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status getProperties(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status globalLexicalScopeNames(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status queryObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status releaseObject(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status releaseObjectGroup(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status runIfWaitingForDebugger(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status runScript(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setCustomObjectFormatterEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status setMaxCallStackSizeToCapture(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status terminateExecution(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status addBinding(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
-        DispatchResponse::Status removeBinding(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void awaitPromise(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void callFunctionOn(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void compileScript(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void discardConsoleEntries(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void evaluate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getIsolateId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getHeapUsage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getProperties(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void globalLexicalScopeNames(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void queryObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void releaseObject(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void releaseObjectGroup(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void runIfWaitingForDebugger(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void runScript(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setCustomObjectFormatterEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void setMaxCallStackSizeToCapture(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void terminateExecution(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void addBinding(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void removeBinding(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
 class AwaitPromiseCallbackImpl : public Backend::AwaitPromiseCallback, public DispatcherBase::Callback {
     public:
-        AwaitPromiseCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        AwaitPromiseCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess(std::unique_ptr<protocol::Runtime::RemoteObject> result, Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails) override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -1395,7 +1391,7 @@ class AwaitPromiseCallbackImpl : public Backend::AwaitPromiseCallback, public Di
         }
 };
 
-DispatchResponse::Status DispatcherImpl::awaitPromise(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::awaitPromise(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1417,19 +1413,19 @@ DispatchResponse::Status DispatcherImpl::awaitPromise(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<AwaitPromiseCallbackImpl> callback(new AwaitPromiseCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<AwaitPromiseCallbackImpl> callback(new AwaitPromiseCallbackImpl(weakPtr(), callId, method, message));
     m_backend->awaitPromise(in_promiseObjectId, std::move(in_returnByValue), std::move(in_generatePreview), std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
 class CallFunctionOnCallbackImpl : public Backend::CallFunctionOnCallback, public DispatcherBase::Callback {
     public:
-        CallFunctionOnCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        CallFunctionOnCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess(std::unique_ptr<protocol::Runtime::RemoteObject> result, Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails) override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -1450,7 +1446,7 @@ class CallFunctionOnCallbackImpl : public Backend::CallFunctionOnCallback, publi
         }
 };
 
-DispatchResponse::Status DispatcherImpl::callFunctionOn(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::callFunctionOn(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1514,16 +1510,16 @@ DispatchResponse::Status DispatcherImpl::callFunctionOn(int callId, std::unique_
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<CallFunctionOnCallbackImpl> callback(new CallFunctionOnCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<CallFunctionOnCallbackImpl> callback(new CallFunctionOnCallbackImpl(weakPtr(), callId, method, message));
     m_backend->callFunctionOn(in_functionDeclaration, std::move(in_objectId), std::move(in_arguments), std::move(in_silent), std::move(in_returnByValue), std::move(in_generatePreview), std::move(in_userGesture), std::move(in_awaitPromise), std::move(in_executionContextId), std::move(in_objectGroup), std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::compileScript(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::compileScript(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1545,7 +1541,7 @@ DispatchResponse::Status DispatcherImpl::compileScript(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     Maybe<String> out_scriptId;
@@ -1554,7 +1550,8 @@ DispatchResponse::Status DispatcherImpl::compileScript(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->compileScript(in_expression, in_sourceURL, in_persistScript, std::move(in_executionContextId), &out_scriptId, &out_exceptionDetails);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1568,52 +1565,55 @@ DispatchResponse::Status DispatcherImpl::compileScript(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::disable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->disable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::discardConsoleEntries(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::discardConsoleEntries(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->discardConsoleEntries();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::enable(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->enable();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 class EvaluateCallbackImpl : public Backend::EvaluateCallback, public DispatcherBase::Callback {
     public:
-        EvaluateCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        EvaluateCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess(std::unique_ptr<protocol::Runtime::RemoteObject> result, Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails) override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -1634,7 +1634,7 @@ class EvaluateCallbackImpl : public Backend::EvaluateCallback, public Dispatcher
         }
 };
 
-DispatchResponse::Status DispatcherImpl::evaluate(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::evaluate(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1704,23 +1704,24 @@ DispatchResponse::Status DispatcherImpl::evaluate(int callId, std::unique_ptr<Di
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<EvaluateCallbackImpl> callback(new EvaluateCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<EvaluateCallbackImpl> callback(new EvaluateCallbackImpl(weakPtr(), callId, method, message));
     m_backend->evaluate(in_expression, std::move(in_objectGroup), std::move(in_includeCommandLineAPI), std::move(in_silent), std::move(in_contextId), std::move(in_returnByValue), std::move(in_generatePreview), std::move(in_userGesture), std::move(in_awaitPromise), std::move(in_throwOnSideEffect), std::move(in_timeout), std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getIsolateId(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getIsolateId(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     String out_id;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getIsolateId(&out_id);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1729,10 +1730,10 @@ DispatchResponse::Status DispatcherImpl::getIsolateId(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getHeapUsage(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getHeapUsage(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     double out_usedSize;
     double out_totalSize;
@@ -1740,7 +1741,8 @@ DispatchResponse::Status DispatcherImpl::getHeapUsage(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getHeapUsage(&out_usedSize, &out_totalSize);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1750,10 +1752,10 @@ DispatchResponse::Status DispatcherImpl::getHeapUsage(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::getProperties(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getProperties(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1781,7 +1783,7 @@ DispatchResponse::Status DispatcherImpl::getProperties(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Runtime::PropertyDescriptor>> out_result;
@@ -1791,7 +1793,8 @@ DispatchResponse::Status DispatcherImpl::getProperties(int callId, std::unique_p
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getProperties(in_objectId, std::move(in_ownProperties), std::move(in_accessorPropertiesOnly), std::move(in_generatePreview), &out_result, &out_internalProperties, &out_exceptionDetails);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1806,10 +1809,10 @@ DispatchResponse::Status DispatcherImpl::getProperties(int callId, std::unique_p
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::globalLexicalScopeNames(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::globalLexicalScopeNames(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1822,7 +1825,7 @@ DispatchResponse::Status DispatcherImpl::globalLexicalScopeNames(int callId, std
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Array<String>> out_names;
@@ -1830,7 +1833,8 @@ DispatchResponse::Status DispatcherImpl::globalLexicalScopeNames(int callId, std
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->globalLexicalScopeNames(std::move(in_executionContextId), &out_names);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1839,10 +1843,10 @@ DispatchResponse::Status DispatcherImpl::globalLexicalScopeNames(int callId, std
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::queryObjects(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::queryObjects(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1858,7 +1862,7 @@ DispatchResponse::Status DispatcherImpl::queryObjects(int callId, std::unique_pt
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
     // Declare output parameters.
     std::unique_ptr<protocol::Runtime::RemoteObject> out_objects;
@@ -1866,7 +1870,8 @@ DispatchResponse::Status DispatcherImpl::queryObjects(int callId, std::unique_pt
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->queryObjects(in_prototypeObjectId, std::move(in_objectGroup), &out_objects);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -1875,10 +1880,10 @@ DispatchResponse::Status DispatcherImpl::queryObjects(int callId, std::unique_pt
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::releaseObject(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::releaseObject(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1888,21 +1893,22 @@ DispatchResponse::Status DispatcherImpl::releaseObject(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->releaseObject(in_objectId);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::releaseObjectGroup(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::releaseObjectGroup(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -1912,37 +1918,39 @@ DispatchResponse::Status DispatcherImpl::releaseObjectGroup(int callId, std::uni
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->releaseObjectGroup(in_objectGroup);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::runIfWaitingForDebugger(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::runIfWaitingForDebugger(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->runIfWaitingForDebugger();
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 class RunScriptCallbackImpl : public Backend::RunScriptCallback, public DispatcherBase::Callback {
     public:
-        RunScriptCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        RunScriptCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess(std::unique_ptr<protocol::Runtime::RemoteObject> result, Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails) override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -1963,7 +1971,7 @@ class RunScriptCallbackImpl : public Backend::RunScriptCallback, public Dispatch
         }
 };
 
-DispatchResponse::Status DispatcherImpl::runScript(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::runScript(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2015,16 +2023,16 @@ DispatchResponse::Status DispatcherImpl::runScript(int callId, std::unique_ptr<D
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<RunScriptCallbackImpl> callback(new RunScriptCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<RunScriptCallbackImpl> callback(new RunScriptCallbackImpl(weakPtr(), callId, method, message));
     m_backend->runScript(in_scriptId, std::move(in_executionContextId), std::move(in_objectGroup), std::move(in_silent), std::move(in_includeCommandLineAPI), std::move(in_returnByValue), std::move(in_generatePreview), std::move(in_awaitPromise), std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setCustomObjectFormatterEnabled(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setCustomObjectFormatterEnabled(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2034,21 +2042,22 @@ DispatchResponse::Status DispatcherImpl::setCustomObjectFormatterEnabled(int cal
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setCustomObjectFormatterEnabled(in_enabled);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::setMaxCallStackSizeToCapture(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::setMaxCallStackSizeToCapture(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2058,24 +2067,25 @@ DispatchResponse::Status DispatcherImpl::setMaxCallStackSizeToCapture(int callId
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->setMaxCallStackSizeToCapture(in_size);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 class TerminateExecutionCallbackImpl : public Backend::TerminateExecutionCallback, public DispatcherBase::Callback {
     public:
-        TerminateExecutionCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
-            : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
+        TerminateExecutionCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const String& message)
+            : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
 
         void sendSuccess() override {
             std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
@@ -2092,15 +2102,15 @@ class TerminateExecutionCallbackImpl : public Backend::TerminateExecutionCallbac
         }
 };
 
-DispatchResponse::Status DispatcherImpl::terminateExecution(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::terminateExecution(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<TerminateExecutionCallbackImpl> callback(new TerminateExecutionCallbackImpl(weakPtr(), callId, nextCallbackId()));
+    std::unique_ptr<TerminateExecutionCallbackImpl> callback(new TerminateExecutionCallbackImpl(weakPtr(), callId, method, message));
     m_backend->terminateExecution(std::move(callback));
-    return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::addBinding(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::addBinding(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2116,21 +2126,22 @@ DispatchResponse::Status DispatcherImpl::addBinding(int callId, std::unique_ptr<
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->addBinding(in_name, std::move(in_executionContextId));
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
-DispatchResponse::Status DispatcherImpl::removeBinding(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::removeBinding(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
@@ -2140,23 +2151,24 @@ DispatchResponse::Status DispatcherImpl::removeBinding(int callId, std::unique_p
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return DispatchResponse::kError;
+        return;
     }
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->removeBinding(in_name);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     if (weak->get()) {
         weak->get()->sendResponse(callId, response);
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Runtime", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Schema.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Schema.cpp
index e3300177f..ab762ab95 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Schema.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/protocol/Schema.cpp
@@ -84,53 +84,50 @@ void Frontend::sendRawNotification(const String& notification) {
 
 class DispatcherImpl : public protocol::DispatcherBase {
     public:
-        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
             : DispatcherBase(frontendChannel)
-            , m_backend(backend)
-            , m_fallThroughForNotFound(fallThroughForNotFound) {
+            , m_backend(backend) {
             m_dispatchMap["Schema.getDomains"] = &DispatcherImpl::getDomains;
         }
         ~DispatcherImpl() override { }
-        DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+        bool canDispatch(const String& method) override;
+        void dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
         std::unordered_map<String, String>& redirects() {
             return m_redirects;
         }
 
     protected:
-        using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
         using DispatchMap = std::unordered_map<String, CallHandler>;
         DispatchMap m_dispatchMap;
         std::unordered_map<String, String> m_redirects;
 
-        DispatchResponse::Status getDomains(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+        void getDomains(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
 
         Backend* m_backend;
-        bool m_fallThroughForNotFound;
 };
 
-DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    if (it == m_dispatchMap.end()) {
-        if (m_fallThroughForNotFound) {
-            return DispatchResponse::kFallThrough;
-        }
-        reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return DispatchResponse::kError;
-    }
+bool DispatcherImpl::canDispatch(const String& method) {
+    return m_dispatchMap.find(method) != m_dispatchMap.end();
+}
 
+void DispatcherImpl::dispatch(int callId, const String& method, const String& message, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    DCHECK(it != m_dispatchMap.end());
     protocol::ErrorSupport errors;
-    return (this->*(it->second))(callId, std::move(messageObject), &errors);
+    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
 }
 
 
-DispatchResponse::Status DispatcherImpl::getDomains(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
+void DispatcherImpl::getDomains(int callId, const String& method, const String& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors) {
     // Declare output parameters.
     std::unique_ptr<protocol::Array<protocol::Schema::Domain>> out_domains;
 
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->getDomains(&out_domains);
     if (response.status() == DispatchResponse::kFallThrough) {
-        return response.status();
+        channel()->fallThrough(callId, method, message);
+        return;
     }
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
@@ -139,12 +136,12 @@ DispatchResponse::Status DispatcherImpl::getDomains(int callId, std::unique_ptr<
     if (weak->get()) {
         weak->get()->sendResponse(callId, response, std::move(result));
     }
-    return response.status();
+    return;
 }
 
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend) {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
     uber->setupRedirects(dispatcher->redirects());
     uber->registerBackend("Schema", std::move(dispatcher));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/remote-object-id.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/remote-object-id.h
index 970f7b062..82d5c99de 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/remote-object-id.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/remote-object-id.h
@@ -19,7 +19,7 @@ class RemoteObjectIdBase {
 
     protected:
         RemoteObjectIdBase();
-        ~RemoteObjectIdBase() {}
+        ~RemoteObjectIdBase() = default;
 
         std::unique_ptr<protocol::DictionaryValue> parseInjectedScriptId(
             const String16&);
@@ -30,7 +30,7 @@ class RemoteObjectIdBase {
 class RemoteObjectId final : public RemoteObjectIdBase {
     public:
         static Response parse(const String16&, std::unique_ptr<RemoteObjectId>*);
-        ~RemoteObjectId() {}
+        ~RemoteObjectId() = default;
         int id() const {
             return m_id;
         }
@@ -44,7 +44,7 @@ class RemoteObjectId final : public RemoteObjectIdBase {
 class RemoteCallFrameId final : public RemoteObjectIdBase {
     public:
         static Response parse(const String16&, std::unique_ptr<RemoteCallFrameId>*);
-        ~RemoteCallFrameId() {}
+        ~RemoteCallFrameId() = default;
 
         int frameOrdinal() const {
             return m_frameOrdinal;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.cc
index f5d8556da..eb77ddd5f 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.cc
@@ -116,13 +116,13 @@ ConversionResult convertUTF16ToUTF8(const UChar** sourceStart,
       }
     }
     // Figure out how many bytes the result will require
-    if (ch < (UChar32)0x80) {
+    if (ch < static_cast<UChar32>(0x80)) {
       bytesToWrite = 1;
-    } else if (ch < (UChar32)0x800) {
+    } else if (ch < static_cast<UChar32>(0x800)) {
       bytesToWrite = 2;
-    } else if (ch < (UChar32)0x10000) {
+    } else if (ch < static_cast<UChar32>(0x10000)) {
       bytesToWrite = 3;
-    } else if (ch < (UChar32)0x110000) {
+    } else if (ch < static_cast<UChar32>(0x110000)) {
       bytesToWrite = 4;
     } else {
       bytesToWrite = 3;
@@ -370,13 +370,13 @@ static inline void putUTF8Triple(char*& buffer, UChar ch) {
 
 }  // namespace
 
-String16::String16() {}
+String16::String16() = default;
 
-String16::String16(const String16& other)
-    : m_impl(other.m_impl), hash_code(other.hash_code) {}
+String16::String16(const String16& other) = default;
 
-String16::String16(String16&& other)
-    : m_impl(std::move(other.m_impl)), hash_code(other.hash_code) {}
+String16::String16(String16&& other) V8_NOEXCEPT
+    : m_impl(std::move(other.m_impl)),
+      hash_code(other.hash_code) {}
 
 String16::String16(const UChar* characters, size_t size)
     : m_impl(characters, size) {}
@@ -393,13 +393,9 @@ String16::String16(const char* characters, size_t size) {
 
 String16::String16(const std::basic_string<UChar>& impl) : m_impl(impl) {}
 
-String16& String16::operator=(const String16& other) {
-  m_impl = other.m_impl;
-  hash_code = other.hash_code;
-  return *this;
-}
+String16& String16::operator=(const String16& other) = default;
 
-String16& String16::operator=(String16&& other) {
+String16& String16::operator=(String16&& other) V8_NOEXCEPT {
   m_impl = std::move(other.m_impl);
   hash_code = other.hash_code;
   return *this;
@@ -470,7 +466,7 @@ String16 String16::stripWhiteSpace() const {
   return String16(characters16() + start, end + 1 - start);
 }
 
-String16Builder::String16Builder() {}
+String16Builder::String16Builder() = default;
 
 void String16Builder::append(const String16& s) {
   m_buffer.insert(m_buffer.end(), s.characters16(),
@@ -546,7 +542,7 @@ String16 String16::fromUTF8(const char* stringStart, size_t length) {
   UChar* bufferCurrent = bufferStart;
   const char* stringCurrent = stringStart;
   if (convertUTF8ToUTF16(&stringCurrent, stringStart + length, &bufferCurrent,
-                         bufferCurrent + buffer.size(), 0,
+                         bufferCurrent + buffer.size(), nullptr,
                          true) != conversionOK)
     return String16();
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.h
index ebae1ff77..d00c9e370 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-16.h
@@ -12,6 +12,8 @@
 #include <string>
 #include <vector>
 
+#include "src/base/compiler-specific.h"
+
 namespace v8_inspector {
 
 using UChar = uint16_t;
@@ -22,7 +24,7 @@ class String16 {
 
         String16();
         String16(const String16& other);
-        String16(String16&& other);
+        String16(String16&& other) V8_NOEXCEPT;
         String16(const UChar* characters, size_t size);
         String16(const UChar* characters);  // NOLINT(runtime/explicit)
         String16(const char* characters);   // NOLINT(runtime/explicit)
@@ -30,7 +32,7 @@ class String16 {
         explicit String16(const std::basic_string<UChar>& impl);
 
         String16& operator=(const String16& other);
-        String16& operator=(String16&& other);
+        String16& operator=(String16&& other) V8_NOEXCEPT;
 
         static String16 fromInteger(int);
         static String16 fromInteger(size_t);
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.cc
index 508229365..79c5dcc9c 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.cc
@@ -52,16 +52,18 @@ v8::Local<v8::String> toV8String(v8::Isolate* isolate,
       .ToLocalChecked();
 }
 
-String16 toProtocolString(v8::Local<v8::String> value) {
+String16 toProtocolString(v8::Isolate* isolate, v8::Local<v8::String> value) {
   if (value.IsEmpty() || value->IsNullOrUndefined()) return String16();
   std::unique_ptr<UChar[]> buffer(new UChar[value->Length()]);
-  value->Write(reinterpret_cast<uint16_t*>(buffer.get()), 0, value->Length());
+  value->Write(isolate, reinterpret_cast<uint16_t*>(buffer.get()), 0,
+               value->Length());
   return String16(buffer.get(), value->Length());
 }
 
-String16 toProtocolStringWithTypeCheck(v8::Local<v8::Value> value) {
+String16 toProtocolStringWithTypeCheck(v8::Isolate* isolate,
+                                       v8::Local<v8::Value> value) {
   if (value.IsEmpty() || !value->IsString()) return String16();
-  return toProtocolString(value.As<v8::String>());
+  return toProtocolString(isolate, value.As<v8::String>());
 }
 
 String16 toString16(const StringView& string) {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.h
index 5d2443934..c49fa533d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/string-util.h
@@ -71,8 +71,8 @@ v8::Local<v8::String> toV8StringInternalized(v8::Isolate*, const String16&);
 v8::Local<v8::String> toV8StringInternalized(v8::Isolate*, const char*);
 v8::Local<v8::String> toV8String(v8::Isolate*, const StringView&);
 // TODO(dgozman): rename to toString16.
-String16 toProtocolString(v8::Local<v8::String>);
-String16 toProtocolStringWithTypeCheck(v8::Local<v8::Value>);
+String16 toProtocolString(v8::Isolate*, v8::Local<v8::String>);
+String16 toProtocolStringWithTypeCheck(v8::Isolate*, v8::Local<v8::Value>);
 String16 toString16(const StringView&);
 StringView toStringView(const String16&);
 bool stringViewStartsWith(const StringView&, const char*);
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/utils/v8-inspector-common.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/utils/v8-inspector-common.cpp
index 0ca919509..c0514ff87 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/utils/v8-inspector-common.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/utils/v8-inspector-common.cpp
@@ -21,7 +21,7 @@ v8::Local<v8::Object> Common::getGlobalInspectorObject(v8::Isolate* isolate) {
     auto maybeInspectorObj = global->Get(context, ArgConverter::ConvertToV8String(isolate, inspectorObjectString));
 
     if (maybeInspectorObj.ToLocal(&outInspector)) {
-        return outInspector->ToObject();
+        return outInspector->ToObject(context).ToLocalChecked();
     }
 
     return v8::Local<v8::Object>();
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-agent-impl.cc
index 96ffdc593..66c96110d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-agent-impl.cc
@@ -24,7 +24,7 @@ V8ConsoleAgentImpl::V8ConsoleAgentImpl(
       m_frontend(frontendChannel),
       m_enabled(false) {}
 
-V8ConsoleAgentImpl::~V8ConsoleAgentImpl() {}
+V8ConsoleAgentImpl::~V8ConsoleAgentImpl() = default;
 
 Response V8ConsoleAgentImpl::enable() {
   if (m_enabled) return Response::OK();
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.cc
index 408f88bc1..6d39deeb4 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.cc
@@ -13,6 +13,7 @@
 #include "src/inspector/v8-inspector-session-impl.h"
 #include "src/inspector/v8-runtime-agent-impl.h"
 #include "src/inspector/v8-stack-trace-impl.h"
+#include "src/tracing/trace-event.h"
 
 #include "include/v8-inspector.h"
 
@@ -118,13 +119,11 @@ class V8ValueStringBuilder {
         !value->IsNativeError() && !value->IsRegExp()) {
       v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
       v8::Local<v8::String> stringValue;
-      if (object->ObjectProtoToString(m_isolate->GetCurrentContext())
-              .ToLocal(&stringValue))
+      if (object->ObjectProtoToString(m_context).ToLocal(&stringValue))
         return append(stringValue);
     }
     v8::Local<v8::String> stringValue;
-    if (!value->ToString(m_isolate->GetCurrentContext()).ToLocal(&stringValue))
-      return false;
+    if (!value->ToString(m_context).ToLocal(&stringValue)) return false;
     return append(stringValue);
   }
 
@@ -160,7 +159,9 @@ class V8ValueStringBuilder {
   }
 
   bool append(v8::Local<v8::BigInt> bigint) {
-    bool result = append(bigint->ToString());
+    v8::Local<v8::String> bigint_string;
+    if (!bigint->ToString(m_context).ToLocal(&bigint_string)) return false;
+    bool result = append(bigint_string);
     if (m_tryCatch.HasCaught()) return false;
     m_builder.append('n');
     return result;
@@ -168,7 +169,9 @@ class V8ValueStringBuilder {
 
   bool append(v8::Local<v8::String> string) {
     if (m_tryCatch.HasCaught()) return false;
-    if (!string.IsEmpty()) m_builder.append(toProtocolString(string));
+    if (!string.IsEmpty()) {
+      m_builder.append(toProtocolString(m_isolate, string));
+    }
     return true;
   }
 
@@ -200,7 +203,7 @@ V8ConsoleMessage::V8ConsoleMessage(V8MessageOrigin origin, double timestamp,
       m_exceptionId(0),
       m_revokedExceptionId(0) {}
 
-V8ConsoleMessage::~V8ConsoleMessage() {}
+V8ConsoleMessage::~V8ConsoleMessage() = default;
 
 void V8ConsoleMessage::setLocation(const String16& url, unsigned lineNumber,
                                    unsigned columnNumber,
@@ -475,12 +478,34 @@ V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8InspectorImpl* inspector,
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage() { clear(); }
 
+namespace {
+
+void TraceV8ConsoleMessageEvent(V8MessageOrigin origin, ConsoleAPIType type) {
+  // Change in this function requires adjustment of Catapult/Telemetry metric
+  // tracing/tracing/metrics/console_error_metric.html.
+  // See https://crbug.com/880432
+  if (origin == V8MessageOrigin::kException) {
+    TRACE_EVENT_INSTANT0("v8.console", "V8ConsoleMessage::Exception",
+                         TRACE_EVENT_SCOPE_THREAD);
+  } else if (type == ConsoleAPIType::kError) {
+    TRACE_EVENT_INSTANT0("v8.console", "V8ConsoleMessage::Error",
+                         TRACE_EVENT_SCOPE_THREAD);
+  } else if (type == ConsoleAPIType::kAssert) {
+    TRACE_EVENT_INSTANT0("v8.console", "V8ConsoleMessage::Assert",
+                         TRACE_EVENT_SCOPE_THREAD);
+  }
+}
+
+}  // anonymous namespace
+
 void V8ConsoleMessageStorage::addMessage(
     std::unique_ptr<V8ConsoleMessage> message) {
   int contextGroupId = m_contextGroupId;
   V8InspectorImpl* inspector = m_inspector;
   if (message->type() == ConsoleAPIType::kClear) clear();
 
+  TraceV8ConsoleMessageEvent(message->origin(), message->type());
+
   inspector->forEachSession(
       contextGroupId, [&message](V8InspectorSessionImpl* session) {
         if (message->origin() == V8MessageOrigin::kConsole)
@@ -540,6 +565,13 @@ bool V8ConsoleMessageStorage::countReset(int contextId, const String16& id) {
   return true;
 }
 
+double V8ConsoleMessageStorage::timeLog(int contextId, const String16& id) {
+  std::map<String16, double>& time = m_data[contextId].m_time;
+  auto it = time.find(id);
+  if (it == time.end()) return 0.0;
+  return m_inspector->client()->currentTimeMS() - it->second;
+}
+
 double V8ConsoleMessageStorage::timeEnd(int contextId, const String16& id) {
   std::map<String16, double>& time = m_data[contextId].m_time;
   auto it = time.find(id);
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.h
index 75588d45a..349d754bf 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console-message.h
@@ -122,6 +122,7 @@ class V8ConsoleMessageStorage {
         int count(int contextId, const String16& id);
         bool countReset(int contextId, const String16& id);
         void time(int contextId, const String16& id);
+        double timeLog(int contextId, const String16& id);
         double timeEnd(int contextId, const String16& id);
         bool hasTimer(int contextId, const String16& id);
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.cc
index faba4a082..ef4c7ccd1 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.cc
@@ -24,9 +24,9 @@ namespace v8_inspector {
 namespace {
 
 String16 consoleContextToString(
-    const v8::debug::ConsoleContext& consoleContext) {
+    v8::Isolate* isolate, const v8::debug::ConsoleContext& consoleContext) {
   if (consoleContext.id() == 0) return String16();
-  return toProtocolString(consoleContext.name()) + "#" +
+  return toProtocolString(isolate, consoleContext.name()) + "#" +
          String16::fromInteger(consoleContext.id());
 }
 
@@ -63,6 +63,7 @@ class ConsoleHelper {
   void reportCall(ConsoleAPIType type) {
     if (!m_info.Length()) return;
     std::vector<v8::Local<v8::Value>> arguments;
+    arguments.reserve(m_info.Length());
     for (int i = 0; i < m_info.Length(); ++i) arguments.push_back(m_info[i]);
     reportCall(type, arguments);
   }
@@ -75,6 +76,14 @@ class ConsoleHelper {
     reportCall(type, arguments);
   }
 
+  void reportCallAndReplaceFirstArgument(ConsoleAPIType type,
+                                         const String16& message) {
+    std::vector<v8::Local<v8::Value>> arguments;
+    arguments.push_back(toV8String(m_isolate, message));
+    for (int i = 1; i < m_info.Length(); ++i) arguments.push_back(m_info[i]);
+    reportCall(type, arguments);
+  }
+
   void reportCallWithArgument(ConsoleAPIType type, const String16& message) {
     std::vector<v8::Local<v8::Value>> arguments(1,
                                                 toV8String(m_isolate, message));
@@ -88,7 +97,7 @@ class ConsoleHelper {
         V8ConsoleMessage::createForConsoleAPI(
             m_context, m_contextId, m_groupId, m_inspector,
             m_inspector->client()->currentTimeMS(), type, arguments,
-            consoleContextToString(m_consoleContext),
+            consoleContextToString(m_isolate, m_consoleContext),
             m_inspector->debugger()->captureStackTrace(false));
     consoleMessageStorage()->addMessage(std::move(message));
   }
@@ -106,7 +115,7 @@ class ConsoleHelper {
   bool firstArgToBoolean(bool defaultValue) {
     if (m_info.Length() < 1) return defaultValue;
     if (m_info[0]->IsBoolean()) return m_info[0].As<v8::Boolean>()->Value();
-    return m_info[0]->BooleanValue(m_context).FromMaybe(defaultValue);
+    return m_info[0]->BooleanValue(m_context->GetIsolate());
   }
 
   String16 firstArgToString(const String16& defaultValue,
@@ -124,7 +133,7 @@ class ConsoleHelper {
       if (!m_info[0]->ToString(m_context).ToLocal(&titleValue))
         return defaultValue;
     }
-    return toProtocolString(titleValue);
+    return toProtocolString(m_context->GetIsolate(), titleValue);
   }
 
   v8::MaybeLocal<v8::Object> firstArgAsObject() {
@@ -143,7 +152,7 @@ class ConsoleHelper {
   }
 
   void forEachSession(std::function<void(V8InspectorSessionImpl*)> callback) {
-    m_inspector->forEachSession(m_groupId, callback);
+    m_inspector->forEachSession(m_groupId, std::move(callback));
   }
 
  private:
@@ -297,7 +306,8 @@ static String16 identifierFromTitleOrStackTrace(
   } else {
     identifier = title + "@";
   }
-  identifier = consoleContextToString(consoleContext) + "@" + identifier;
+  identifier = consoleContextToString(inspector->isolate(), consoleContext) +
+               "@" + identifier;
 
   return identifier;
 }
@@ -370,7 +380,8 @@ static void timeFunction(const v8::debug::ConsoleCallArguments& info,
   String16 protocolTitle = helper.firstArgToString("default", false);
   if (timelinePrefix) protocolTitle = "Timeline '" + protocolTitle + "'";
   const String16& timerId =
-      protocolTitle + "@" + consoleContextToString(consoleContext);
+      protocolTitle + "@" +
+      consoleContextToString(inspector->isolate(), consoleContext);
   if (helper.consoleMessageStorage()->hasTimer(helper.contextId(), timerId)) {
     helper.reportCallWithArgument(
         ConsoleAPIType::kWarning,
@@ -383,12 +394,12 @@ static void timeFunction(const v8::debug::ConsoleCallArguments& info,
 
 static void timeEndFunction(const v8::debug::ConsoleCallArguments& info,
                             const v8::debug::ConsoleContext& consoleContext,
-                            bool timelinePrefix, V8InspectorImpl* inspector) {
+                            bool timeLog, V8InspectorImpl* inspector) {
   ConsoleHelper helper(info, consoleContext, inspector);
   String16 protocolTitle = helper.firstArgToString("default", false);
-  if (timelinePrefix) protocolTitle = "Timeline '" + protocolTitle + "'";
   const String16& timerId =
-      protocolTitle + "@" + consoleContextToString(consoleContext);
+      protocolTitle + "@" +
+      consoleContextToString(inspector->isolate(), consoleContext);
   if (!helper.consoleMessageStorage()->hasTimer(helper.contextId(), timerId)) {
     helper.reportCallWithArgument(
         ConsoleAPIType::kWarning,
@@ -396,12 +407,22 @@ static void timeEndFunction(const v8::debug::ConsoleCallArguments& info,
     return;
   }
   inspector->client()->consoleTimeEnd(toStringView(protocolTitle));
-  double elapsed = helper.consoleMessageStorage()->timeEnd(
-      helper.contextId(),
-      protocolTitle + "@" + consoleContextToString(consoleContext));
+  String16 title = protocolTitle + "@" +
+                   consoleContextToString(inspector->isolate(), consoleContext);
+  double elapsed;
+  if (timeLog) {
+    elapsed =
+        helper.consoleMessageStorage()->timeLog(helper.contextId(), title);
+  } else {
+    elapsed =
+        helper.consoleMessageStorage()->timeEnd(helper.contextId(), title);
+  }
   String16 message =
       protocolTitle + ": " + String16::fromDouble(elapsed) + "ms";
-  helper.reportCallWithArgument(ConsoleAPIType::kTimeEnd, message);
+  if (timeLog)
+    helper.reportCallAndReplaceFirstArgument(ConsoleAPIType::kLog, message);
+  else
+    helper.reportCallWithArgument(ConsoleAPIType::kTimeEnd, message);
 }
 
 void V8Console::Time(const v8::debug::ConsoleCallArguments& info,
@@ -409,6 +430,11 @@ void V8Console::Time(const v8::debug::ConsoleCallArguments& info,
   timeFunction(info, consoleContext, false, m_inspector);
 }
 
+void V8Console::TimeLog(const v8::debug::ConsoleCallArguments& info,
+                        const v8::debug::ConsoleContext& consoleContext) {
+  timeEndFunction(info, consoleContext, true, m_inspector);
+}
+
 void V8Console::TimeEnd(const v8::debug::ConsoleCallArguments& info,
                         const v8::debug::ConsoleContext& consoleContext) {
   timeEndFunction(info, consoleContext, false, m_inspector);
@@ -527,7 +553,8 @@ void V8Console::monitorFunctionCallback(
   v8::Local<v8::Value> name = function->GetName();
   if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
     name = function->GetInferredName();
-  String16 functionName = toProtocolStringWithTypeCheck(name);
+  String16 functionName =
+      toProtocolStringWithTypeCheck(info.GetIsolate(), name);
   String16Builder builder;
   builder.append("console.log(\"function ");
   if (functionName.isEmpty())
@@ -779,7 +806,8 @@ void V8Console::CommandLineAPIScope::accessorGetterCallback(
 
   v8::Local<v8::Value> value;
   if (!commandLineAPI->Get(context, name).ToLocal(&value)) return;
-  if (isCommandLineAPIGetter(toProtocolStringWithTypeCheck(name))) {
+  if (isCommandLineAPIGetter(
+          toProtocolStringWithTypeCheck(info.GetIsolate(), name))) {
     DCHECK(value->IsFunction());
     v8::MicrotasksScope microtasks(info.GetIsolate(),
                                    v8::MicrotasksScope::kDoNotRunMicrotasks);
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.h
index dc6f8a9be..98bef79c5 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-console.h
@@ -88,6 +88,8 @@ class V8Console : public v8::debug::ConsoleDelegate {
                         const v8::debug::ConsoleContext& consoleContext) override;
         void Time(const v8::debug::ConsoleCallArguments&,
                   const v8::debug::ConsoleContext& consoleContext) override;
+        void TimeLog(const v8::debug::ConsoleCallArguments&,
+                     const v8::debug::ConsoleContext& consoleContext) override;
         void TimeEnd(const v8::debug::ConsoleCallArguments&,
                      const v8::debug::ConsoleContext& consoleContext) override;
         void TimeStamp(const v8::debug::ConsoleCallArguments&,
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-css-agent-impl.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-css-agent-impl.cpp
index b19c5c18b..abaa8d713 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-css-agent-impl.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-css-agent-impl.cpp
@@ -165,7 +165,7 @@ DispatchResponse V8CSSAgentImpl::getComputedStyleForNode(int in_nodeId, std::uni
             v8::Local<v8::Value> outResult;
 
             if (maybeResult.ToLocal(&outResult)) {
-                auto resultString = ArgConverter::ConvertToString(outResult->ToString());
+                auto resultString = ArgConverter::ConvertToString(outResult->ToString(context).ToLocalChecked());
                 auto resultCStr = resultString.c_str();
                 auto resultJson = protocol::StringUtil::parseJSON(resultCStr);
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.cc
index e4e6492b6..d227526d6 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.cc
@@ -160,9 +160,8 @@ String16 breakpointHint(const V8DebuggerScript& script, int lineNumber,
                         int columnNumber) {
   int offset = script.offset(lineNumber, columnNumber);
   if (offset == V8DebuggerScript::kNoOffset) return String16();
-  const String16& source = script.source();
   String16 hint =
-      source.substring(offset, kBreakpointHintMaxLength).stripWhiteSpace();
+      script.source(offset, kBreakpointHintMaxLength).stripWhiteSpace();
   for (size_t i = 0; i < hint.length(); ++i) {
     if (hint[i] == '\r' || hint[i] == '\n' || hint[i] == ';') {
       return hint.substring(0, i);
@@ -183,8 +182,8 @@ void adjustBreakpointLocation(const V8DebuggerScript& script,
   intptr_t searchRegionOffset = std::max(
       sourceOffset - kBreakpointHintMaxSearchOffset, static_cast<intptr_t>(0));
   size_t offset = sourceOffset - searchRegionOffset;
-  String16 searchArea = script.source().substring(
-      searchRegionOffset, offset + kBreakpointHintMaxSearchOffset);
+  String16 searchArea = script.source(searchRegionOffset,
+                                      offset + kBreakpointHintMaxSearchOffset);
 
   size_t nextMatch = searchArea.find(hint, offset);
   size_t prevMatch = searchArea.reverseFind(hint, offset);
@@ -250,7 +249,7 @@ String16 scopeType(v8::debug::ScopeIterator::ScopeType type) {
 
 namespace {
 
-Response buildScopes(v8::debug::ScopeIterator* iterator,
+Response buildScopes(v8::Isolate* isolate, v8::debug::ScopeIterator* iterator,
                      InjectedScript* injectedScript,
                      std::unique_ptr<Array<Scope>>* scopes) {
   *scopes = Array<Scope>::create();
@@ -270,8 +269,8 @@ Response buildScopes(v8::debug::ScopeIterator* iterator,
                      .setObject(std::move(object))
                      .build();
 
-    String16 name =
-        toProtocolStringWithTypeCheck(iterator->GetFunctionDebugName());
+    String16 name = toProtocolStringWithTypeCheck(
+        isolate, iterator->GetFunctionDebugName());
     if (!name.isEmpty()) scope->setName(name);
 
     if (iterator->HasLocationInfo()) {
@@ -317,7 +316,7 @@ V8DebuggerAgentImpl::V8DebuggerAgentImpl(
       m_frontend(frontendChannel),
       m_isolate(m_inspector->isolate()) {}
 
-V8DebuggerAgentImpl::~V8DebuggerAgentImpl() {}
+V8DebuggerAgentImpl::~V8DebuggerAgentImpl() = default;
 
 void V8DebuggerAgentImpl::enableImpl() {
   m_enabled = true;
@@ -334,7 +333,7 @@ void V8DebuggerAgentImpl::enableImpl() {
 
   if (isPaused()) {
     didPause(0, v8::Local<v8::Value>(), std::vector<v8::debug::BreakpointId>(),
-             false, false, false, false);
+             v8::debug::kException, false, false, false);
   }
 }
 
@@ -837,7 +836,7 @@ Response V8DebuggerAgentImpl::searchInContent(
     return Response::Error("No script for id: " + scriptId);
 
   std::vector<std::unique_ptr<protocol::Debugger::SearchMatch>> matches =
-      searchInTextByLinesImpl(m_session, it->second->source(), query,
+      searchInTextByLinesImpl(m_session, it->second->source(0), query,
                               optionalCaseSensitive.fromMaybe(false),
                               optionalIsRegex.fromMaybe(false));
   *results = protocol::Array<protocol::Debugger::SearchMatch>::create();
@@ -859,10 +858,6 @@ Response V8DebuggerAgentImpl::setScriptSource(
   if (it == m_scripts.end()) {
     return Response::Error("No script with given id found");
   }
-  if (it->second->isModule()) {
-    // TODO(kozyatinskiy): LiveEdit should support ES6 module
-    return Response::Error("Editing module's script is not supported.");
-  }
   int contextId = it->second->executionContextId();
   InspectedContext* inspected = m_inspector->getContext(contextId);
   if (!inspected) {
@@ -878,7 +873,7 @@ Response V8DebuggerAgentImpl::setScriptSource(
     *optOutCompileError =
         protocol::Runtime::ExceptionDetails::create()
             .setExceptionId(m_inspector->nextExceptionId())
-            .setText(toProtocolString(result.message))
+            .setText(toProtocolString(m_isolate, result.message))
             .setLineNumber(result.line_number != -1 ? result.line_number - 1
                                                     : 0)
             .setColumnNumber(result.column_number != -1 ? result.column_number
@@ -927,7 +922,7 @@ Response V8DebuggerAgentImpl::getScriptSource(const String16& scriptId,
   ScriptsMap::iterator it = m_scripts.find(scriptId);
   if (it == m_scripts.end())
     return Response::Error("No script for id: " + scriptId);
-  *scriptSource = it->second->source();
+  *scriptSource = it->second->source(0);
   return Response::OK();
 }
 
@@ -1265,7 +1260,8 @@ Response V8DebuggerAgentImpl::currentCallFrames(
 
     std::unique_ptr<Array<Scope>> scopes;
     auto scopeIterator = iterator->GetScopeIterator();
-    Response res = buildScopes(scopeIterator.get(), injectedScript, &scopes);
+    Response res =
+        buildScopes(m_isolate, scopeIterator.get(), injectedScript, &scopes);
     if (!res.isSuccess()) return res;
 
     std::unique_ptr<RemoteObject> protocolReceiver;
@@ -1300,15 +1296,15 @@ Response V8DebuggerAgentImpl::currentCallFrames(
       url = scriptIterator->second->sourceURL();
     }
 
-    auto frame =
-        CallFrame::create()
-            .setCallFrameId(callFrameId)
-            .setFunctionName(toProtocolString(iterator->GetFunctionDebugName()))
-            .setLocation(std::move(location))
-            .setUrl(url)
-            .setScopeChain(std::move(scopes))
-            .setThis(std::move(protocolReceiver))
-            .build();
+    auto frame = CallFrame::create()
+                     .setCallFrameId(callFrameId)
+                     .setFunctionName(toProtocolString(
+                         m_isolate, iterator->GetFunctionDebugName()))
+                     .setLocation(std::move(location))
+                     .setUrl(url)
+                     .setScopeChain(std::move(scopes))
+                     .setThis(std::move(protocolReceiver))
+                     .build();
 
     v8::Local<v8::Function> func = iterator->GetFunction();
     if (!func.IsEmpty()) {
@@ -1379,7 +1375,7 @@ void V8DebuggerAgentImpl::didParseSource(
   v8::HandleScope handles(m_isolate);
   if (!success) {
     DCHECK(!script->isSourceLoadedLazily());
-    String16 scriptSource = script->source();
+    String16 scriptSource = script->source(0);
     script->setSourceURL(findSourceURL(scriptSource, false));
     script->setSourceMappingURL(findSourceMapURL(scriptSource, false));
   }
@@ -1396,7 +1392,7 @@ void V8DebuggerAgentImpl::didParseSource(
         protocol::StringUtil::parseJSON(inspected->auxData()));
   }
   bool isLiveEdit = script->isLiveEdit();
-  bool hasSourceURL = script->hasSourceURL();
+  bool hasSourceURLComment = script->hasSourceURLComment();
   bool isModule = script->isModule();
   String16 scriptId = script->scriptId();
   String16 scriptURL = script->sourceURL();
@@ -1416,7 +1412,8 @@ void V8DebuggerAgentImpl::didParseSource(
   Maybe<protocol::DictionaryValue> executionContextAuxDataParam(
       std::move(executionContextAuxData));
   const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
-  const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
+  const bool* hasSourceURLParam =
+      hasSourceURLComment ? &hasSourceURLComment : nullptr;
   const bool* isModuleParam = isModule ? &isModule : nullptr;
   std::unique_ptr<V8StackTraceImpl> stack =
       V8StackTraceImpl::capture(m_inspector->debugger(), contextGroupId, 1);
@@ -1438,8 +1435,7 @@ void V8DebuggerAgentImpl::didParseSource(
           scriptRef->endLine(), scriptRef->endColumn(), contextId,
           scriptRef->hash(), std::move(executionContextAuxDataParam),
           isLiveEditParam, std::move(sourceMapURLParam), hasSourceURLParam,
-          isModuleParam, static_cast<int>(scriptRef->source().length()),
-          std::move(stackTrace));
+          isModuleParam, scriptRef->length(), std::move(stackTrace));
     }
   } else {
     m_frontend.scriptFailedToParse(
@@ -1447,7 +1443,7 @@ void V8DebuggerAgentImpl::didParseSource(
         scriptRef->endLine(), scriptRef->endColumn(), contextId,
         scriptRef->hash(), std::move(executionContextAuxDataParam),
         std::move(sourceMapURLParam), hasSourceURLParam, isModuleParam,
-        static_cast<int>(scriptRef->source().length()), std::move(stackTrace));
+        scriptRef->length(), std::move(stackTrace));
   }
 
   if (!success) {
@@ -1510,7 +1506,8 @@ void V8DebuggerAgentImpl::didParseSource(
 void V8DebuggerAgentImpl::didPause(
     int contextId, v8::Local<v8::Value> exception,
     const std::vector<v8::debug::BreakpointId>& hitBreakpoints,
-    bool isPromiseRejection, bool isUncaught, bool isOOMBreak, bool isAssert) {
+    v8::debug::ExceptionType exceptionType, bool isUncaught, bool isOOMBreak,
+    bool isAssert) {
   v8::HandleScope handles(m_isolate);
 
   std::vector<BreakReason> hitReasons;
@@ -1526,7 +1523,7 @@ void V8DebuggerAgentImpl::didPause(
     m_session->findInjectedScript(contextId, injectedScript);
     if (injectedScript) {
       String16 breakReason =
-          isPromiseRejection
+          exceptionType == v8::debug::kPromiseRejection
               ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection
               : protocol::Debugger::Paused::ReasonEnum::Exception;
       std::unique_ptr<protocol::Runtime::RemoteObject> obj;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.h
index 6692d6c6e..9384a2c5c 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-agent-impl.h
@@ -144,8 +144,8 @@ class V8DebuggerAgentImpl : public protocol::Debugger::Backend {
         // Interface for V8InspectorImpl
         void didPause(int contextId, v8::Local<v8::Value> exception,
                       const std::vector<v8::debug::BreakpointId>& hitBreakpoints,
-                      bool isPromiseRejection, bool isUncaught, bool isOOMBreak,
-                      bool isAssert);
+                      v8::debug::ExceptionType exceptionType, bool isUncaught,
+                      bool isOOMBreak, bool isAssert);
         void didContinue();
         void didParseSource(std::unique_ptr<V8DebuggerScript>, bool success);
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.cc
index c40477ae2..c1efd2dba 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.cc
@@ -6,8 +6,9 @@
 
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/string-util.h"
+#include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/wasm-translation.h"
-#include "src/utils.h"
+#include "src/v8memory.h"
 
 namespace v8_inspector {
 
@@ -19,7 +20,7 @@ const char kGlobalDebuggerScriptHandleLabel[] = "DevTools debugger";
 // Multiplikation in
 // eingeschränkten Branchingprogrammmodellen" by Woelfe.
 // http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
-String16 calculateHash(const String16& str) {
+String16 calculateHash(v8::Isolate* isolate, v8::Local<v8::String> source) {
   static uint64_t prime[] = {0x3FB75161, 0xAB1F4E4F, 0x82675BC5, 0xCD924D35,
                              0x81ABE279};
   static uint64_t random[] = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476,
@@ -33,9 +34,14 @@ String16 calculateHash(const String16& str) {
   const size_t hashesSize = arraysize(hashes);
 
   size_t current = 0;
+
+  std::unique_ptr<UChar[]> buffer(new UChar[source->Length()]);
+  int written = source->Write(
+      isolate, reinterpret_cast<uint16_t*>(buffer.get()), 0, source->Length());
+
   const uint32_t* data = nullptr;
-  size_t sizeInBytes = sizeof(UChar) * str.length();
-  data = reinterpret_cast<const uint32_t*>(str.characters16());
+  size_t sizeInBytes = sizeof(UChar) * written;
+  data = reinterpret_cast<const uint32_t*>(buffer.get());
   for (size_t i = 0; i < sizeInBytes / 4; ++i) {
     uint32_t d = v8::internal::ReadUnalignedUInt32(
         reinterpret_cast<v8::internal::Address>(data + i));
@@ -75,7 +81,7 @@ String16 calculateHash(const String16& str) {
 
   String16Builder hash;
   for (size_t i = 0; i < hashesSize; ++i)
-    hash.appendUnsignedAsHex((uint32_t)hashes[i]);
+    hash.appendUnsignedAsHex(static_cast<uint32_t>(hashes[i]));
   return hash.toString();
 }
 
@@ -110,9 +116,9 @@ class ActualScript : public V8DebuggerScript {
 
  public:
   ActualScript(v8::Isolate* isolate, v8::Local<v8::debug::Script> script,
-               bool isLiveEdit)
+               bool isLiveEdit, V8InspectorClient* client)
       : V8DebuggerScript(isolate, String16::fromInteger(script->Id()),
-                         GetNameOrSourceUrl(script)),
+                         GetScriptURL(isolate, script, client)),
         m_isLiveEdit(isLiveEdit) {
     Initialize(script);
   }
@@ -120,12 +126,29 @@ class ActualScript : public V8DebuggerScript {
   bool isLiveEdit() const override { return m_isLiveEdit; }
   bool isModule() const override { return m_isModule; }
 
-  const String16& source() const override { return m_source; }
+  String16 source(size_t pos, size_t len) const override {
+    v8::HandleScope scope(m_isolate);
+    v8::Local<v8::String> v8Source;
+    if (!script()->Source().ToLocal(&v8Source)) return String16();
+    if (pos >= static_cast<size_t>(v8Source->Length())) return String16();
+    size_t substringLength =
+        std::min(len, static_cast<size_t>(v8Source->Length()) - pos);
+    std::unique_ptr<UChar[]> buffer(new UChar[substringLength]);
+    v8Source->Write(m_isolate, reinterpret_cast<uint16_t*>(buffer.get()),
+                    static_cast<int>(pos), static_cast<int>(substringLength));
+    return String16(buffer.get(), substringLength);
+  }
   int startLine() const override { return m_startLine; }
   int startColumn() const override { return m_startColumn; }
   int endLine() const override { return m_endLine; }
   int endColumn() const override { return m_endColumn; }
   bool isSourceLoadedLazily() const override { return false; }
+  int length() const override {
+    v8::HandleScope scope(m_isolate);
+    v8::Local<v8::String> v8Source;
+    if (!script()->Source().ToLocal(&v8Source)) return 0;
+    return v8Source->Length();
+  }
 
   const String16& sourceMappingURL() const override {
     return m_sourceMappingURL;
@@ -137,7 +160,6 @@ class ActualScript : public V8DebuggerScript {
 
   void setSource(const String16& newSource, bool preview,
                  v8::debug::LiveEditResult* result) override {
-    DCHECK(!isModule());
     v8::EscapableHandleScope scope(m_isolate);
     v8::Local<v8::String> v8Source = toV8String(m_isolate, newSource);
     if (!m_script.Get(m_isolate)->SetScriptSource(v8Source, preview, result)) {
@@ -212,16 +234,31 @@ class ActualScript : public V8DebuggerScript {
   }
 
   const String16& hash() const override {
-    if (m_hash.isEmpty()) m_hash = calculateHash(source());
+    if (m_hash.isEmpty()) {
+      v8::HandleScope scope(m_isolate);
+      v8::Local<v8::String> v8Source;
+      if (script()->Source().ToLocal(&v8Source)) {
+        m_hash = calculateHash(m_isolate, v8Source);
+      }
+    }
     DCHECK(!m_hash.isEmpty());
     return m_hash;
   }
 
  private:
-  String16 GetNameOrSourceUrl(v8::Local<v8::debug::Script> script) {
-    v8::Local<v8::String> name;
-    if (script->Name().ToLocal(&name) || script->SourceURL().ToLocal(&name))
-      return toProtocolString(name);
+  String16 GetScriptURL(v8::Isolate* isolate,
+                        v8::Local<v8::debug::Script> script,
+                        V8InspectorClient* client) {
+    v8::Local<v8::String> sourceURL;
+    if (script->SourceURL().ToLocal(&sourceURL) && sourceURL->Length() > 0)
+      return toProtocolString(isolate, sourceURL);
+    v8::Local<v8::String> v8Name;
+    if (script->Name().ToLocal(&v8Name) && v8Name->Length() > 0) {
+      String16 name = toProtocolString(isolate, v8Name);
+      std::unique_ptr<StringBuffer> url =
+          client->resourceNameToUrl(toStringView(name));
+      return url ? toString16(url->string()) : name;
+    }
     return String16();
   }
 
@@ -231,9 +268,10 @@ class ActualScript : public V8DebuggerScript {
 
   void Initialize(v8::Local<v8::debug::Script> script) {
     v8::Local<v8::String> tmp;
-    if (script->SourceURL().ToLocal(&tmp)) m_sourceURL = toProtocolString(tmp);
+    m_hasSourceURLComment =
+        script->SourceURL().ToLocal(&tmp) && tmp->Length() > 0;
     if (script->SourceMappingURL().ToLocal(&tmp))
-      m_sourceMappingURL = toProtocolString(tmp);
+      m_sourceMappingURL = toProtocolString(m_isolate, tmp);
     m_startLine = script->LineOffset();
     m_startColumn = script->ColumnOffset();
     std::vector<int> lineEnds = script->LineEnds();
@@ -253,10 +291,6 @@ class ActualScript : public V8DebuggerScript {
 
     USE(script->ContextId().To(&m_executionContextId));
 
-    if (script->Source().ToLocal(&tmp)) {
-      m_source = toProtocolString(tmp);
-    }
-
     m_isModule = script->IsModule();
 
     m_script.Reset(m_isolate, script);
@@ -266,7 +300,6 @@ class ActualScript : public V8DebuggerScript {
   String16 m_sourceMappingURL;
   bool m_isLiveEdit = false;
   bool m_isModule = false;
-  String16 m_source;
   mutable String16 m_hash;
   int m_startLine = 0;
   int m_startColumn = 0;
@@ -298,8 +331,9 @@ class WasmVirtualScript : public V8DebuggerScript {
     UNREACHABLE();
   }
   bool isSourceLoadedLazily() const override { return true; }
-  const String16& source() const override {
-    return m_wasmTranslation->GetSource(m_id, m_functionIndex);
+  String16 source(size_t pos, size_t len) const override {
+    return m_wasmTranslation->GetSource(m_id, m_functionIndex)
+        .substring(pos, len);
   }
   int startLine() const override {
     return m_wasmTranslation->GetStartLine(m_id, m_functionIndex);
@@ -313,6 +347,9 @@ class WasmVirtualScript : public V8DebuggerScript {
   int endColumn() const override {
     return m_wasmTranslation->GetEndColumn(m_id, m_functionIndex);
   }
+  int length() const override {
+    return static_cast<int>(source(0, UINT_MAX).length());
+  }
 
   bool getPossibleBreakpoints(
       const v8::debug::Location& start, const v8::debug::Location& end,
@@ -398,9 +435,9 @@ class WasmVirtualScript : public V8DebuggerScript {
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::Create(
     v8::Isolate* isolate, v8::Local<v8::debug::Script> scriptObj,
-    bool isLiveEdit) {
+    bool isLiveEdit, V8InspectorClient* client) {
   return std::unique_ptr<ActualScript>(
-      new ActualScript(isolate, scriptObj, isLiveEdit));
+      new ActualScript(isolate, scriptObj, isLiveEdit, client));
 }
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::CreateWasm(
@@ -416,14 +453,13 @@ V8DebuggerScript::V8DebuggerScript(v8::Isolate* isolate, String16 id,
                                    String16 url)
     : m_id(std::move(id)), m_url(std::move(url)), m_isolate(isolate) {}
 
-V8DebuggerScript::~V8DebuggerScript() {}
-
-const String16& V8DebuggerScript::sourceURL() const {
-  return m_sourceURL.isEmpty() ? m_url : m_sourceURL;
-}
+V8DebuggerScript::~V8DebuggerScript() = default;
 
 void V8DebuggerScript::setSourceURL(const String16& sourceURL) {
-  m_sourceURL = sourceURL;
+  if (sourceURL.length() > 0) {
+    m_hasSourceURLComment = true;
+    m_url = sourceURL;
+  }
 }
 
 bool V8DebuggerScript::setBreakpoint(const String16& condition,
@@ -431,5 +467,4 @@ bool V8DebuggerScript::setBreakpoint(const String16& condition,
   v8::HandleScope scope(m_isolate);
   return script()->SetBreakpoint(toV8String(m_isolate, condition), loc, id);
 }
-
 }  // namespace v8_inspector
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.h
index e09dd8e12..2c1f0b5be 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger-script.h
@@ -40,13 +40,14 @@
 namespace v8_inspector {
 
 // Forward declaration.
+class V8InspectorClient;
 class WasmTranslation;
 
 class V8DebuggerScript {
     public:
         static std::unique_ptr<V8DebuggerScript> Create(
             v8::Isolate* isolate, v8::Local<v8::debug::Script> script,
-            bool isLiveEdit);
+            bool isLiveEdit, V8InspectorClient* client);
         static std::unique_ptr<V8DebuggerScript> CreateWasm(
             v8::Isolate* isolate, WasmTranslation* wasmTranslation,
             v8::Local<v8::debug::WasmScript> underlyingScript, String16 id,
@@ -57,15 +58,15 @@ class V8DebuggerScript {
         const String16& scriptId() const {
             return m_id;
         }
-        const String16& url() const {
-            return m_url;
+        bool hasSourceURLComment() const {
+            return m_hasSourceURLComment;
         }
-        bool hasSourceURL() const {
-            return !m_sourceURL.isEmpty();
+        const String16& sourceURL() const {
+            return m_url;
         }
-        const String16& sourceURL() const;
+
         virtual const String16& sourceMappingURL() const = 0;
-        virtual const String16& source() const = 0;
+        virtual String16 source(size_t pos, size_t len = UINT_MAX) const = 0;
         virtual const String16& hash() const = 0;
         virtual int startLine() const = 0;
         virtual int startColumn() const = 0;
@@ -77,6 +78,7 @@ class V8DebuggerScript {
         virtual bool isLiveEdit() const = 0;
         virtual bool isModule() const = 0;
         virtual bool isSourceLoadedLazily() const = 0;
+        virtual int length() const = 0;
 
         void setSourceURL(const String16&);
         virtual void setSourceMappingURL(const String16&) = 0;
@@ -103,7 +105,7 @@ class V8DebuggerScript {
 
         String16 m_id;
         String16 m_url;
-        String16 m_sourceURL;
+        bool m_hasSourceURLComment = false;
         int m_executionContextId = 0;
 
         v8::Isolate* m_isolate;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.cc
index ed8d943ff..5f826b56a 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.cc
@@ -226,13 +226,15 @@ void V8Debugger::getCompiledScripts(
     v8::Local<v8::debug::Script> script = scripts.Get(i);
     if (!script->WasCompiled()) continue;
     if (script->IsEmbedded()) {
-      result.push_back(V8DebuggerScript::Create(m_isolate, script, false));
+      result.push_back(V8DebuggerScript::Create(m_isolate, script, false,
+                                                m_inspector->client()));
       continue;
     }
     int contextId;
     if (!script->ContextId().To(&contextId)) continue;
     if (m_inspector->contextGroupId(contextId) != contextGroupId) continue;
-    result.push_back(V8DebuggerScript::Create(m_isolate, script, false));
+    result.push_back(V8DebuggerScript::Create(m_isolate, script, false,
+                                              m_inspector->client()));
   }
 }
 
@@ -478,7 +480,7 @@ void V8Debugger::clearContinueToLocation() {
 void V8Debugger::handleProgramBreak(
     v8::Local<v8::Context> pausedContext, v8::Local<v8::Value> exception,
     const std::vector<v8::debug::BreakpointId>& breakpointIds,
-    bool isPromiseRejection, bool isUncaught) {
+    v8::debug::ExceptionType exceptionType, bool isUncaught) {
   // Don't allow nested breaks.
   if (isPaused()) return;
 
@@ -521,12 +523,12 @@ void V8Debugger::handleProgramBreak(
 
   m_inspector->forEachSession(
       contextGroupId, [&pausedContext, &exception, &breakpointIds,
-                       &isPromiseRejection, &isUncaught, &scheduledOOMBreak,
+                       &exceptionType, &isUncaught, &scheduledOOMBreak,
                        &scheduledAssertBreak](V8InspectorSessionImpl* session) {
         if (session->debuggerAgent()->acceptsPause(scheduledOOMBreak)) {
           session->debuggerAgent()->didPause(
               InspectedContext::contextId(pausedContext), exception,
-              breakpointIds, isPromiseRejection, isUncaught, scheduledOOMBreak,
+              breakpointIds, exceptionType, isUncaught, scheduledOOMBreak,
               scheduledAssertBreak);
         }
       });
@@ -574,7 +576,7 @@ void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
                                 bool is_live_edited, bool has_compile_error) {
   int contextId;
   if (!script->ContextId().To(&contextId)) return;
-  if (script->IsWasm()) {
+  if (script->IsWasm() && script->SourceMappingURL().IsEmpty()) {
     WasmTranslation* wasmTranslation = &m_wasmTranslation;
     m_inspector->forEachSession(
         m_inspector->contextGroupId(contextId),
@@ -585,13 +587,14 @@ void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
         });
   } else if (m_ignoreScriptParsedEventsCounter == 0) {
     v8::Isolate* isolate = m_isolate;
+    V8InspectorClient* client = m_inspector->client();
     m_inspector->forEachSession(
         m_inspector->contextGroupId(contextId),
-        [&isolate, &script, &has_compile_error,
-         &is_live_edited](V8InspectorSessionImpl* session) {
+        [&isolate, &script, &has_compile_error, &is_live_edited,
+         &client](V8InspectorSessionImpl* session) {
           if (!session->debuggerAgent()->enabled()) return;
           session->debuggerAgent()->didParseSource(
-              V8DebuggerScript::Create(isolate, script, is_live_edited),
+              V8DebuggerScript::Create(isolate, script, is_live_edited, client),
               !has_compile_error);
         });
   }
@@ -605,12 +608,11 @@ void V8Debugger::BreakProgramRequested(
 
 void V8Debugger::ExceptionThrown(v8::Local<v8::Context> pausedContext,
                                  v8::Local<v8::Value> exception,
-                                 v8::Local<v8::Value> promise,
-                                 bool isUncaught) {
-  bool isPromiseRejection = promise->IsPromise();
+                                 v8::Local<v8::Value> promise, bool isUncaught,
+                                 v8::debug::ExceptionType exceptionType) {
   std::vector<v8::debug::BreakpointId> break_points_hit;
-  handleProgramBreak(pausedContext, exception, break_points_hit,
-                     isPromiseRejection, isUncaught);
+  handleProgramBreak(pausedContext, exception, break_points_hit, exceptionType,
+                     isUncaught);
 }
 
 bool V8Debugger::IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
@@ -719,7 +721,7 @@ v8::MaybeLocal<v8::Value> V8Debugger::getTargetScopes(
     String16 name;
     v8::Local<v8::Value> maybe_name = iterator->GetFunctionDebugName();
     if (!maybe_name->IsUndefined()) {
-      name = toProtocolStringWithTypeCheck(maybe_name);
+      name = toProtocolStringWithTypeCheck(m_isolate, maybe_name);
     }
     v8::Local<v8::Object> object = iterator->GetObject();
     createDataProperty(context, scope,
@@ -748,11 +750,37 @@ v8::MaybeLocal<v8::Value> V8Debugger::generatorScopes(
   return getTargetScopes(context, generator, GENERATOR);
 }
 
+v8::MaybeLocal<v8::Uint32> V8Debugger::stableObjectId(
+    v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
+  DCHECK(value->IsObject());
+  if (m_stableObjectId.IsEmpty()) {
+    m_stableObjectId.Reset(m_isolate, v8::debug::WeakMap::New(m_isolate));
+  }
+  v8::Local<v8::debug::WeakMap> stableObjectId =
+      m_stableObjectId.Get(m_isolate);
+  v8::Local<v8::Value> idValue;
+  if (!stableObjectId->Get(context, value).ToLocal(&idValue) ||
+      !idValue->IsUint32()) {
+    idValue = v8::Integer::NewFromUnsigned(m_isolate, ++m_lastStableObjectId);
+    stableObjectId->Set(context, value, idValue).ToLocalChecked();
+  }
+  return idValue.As<v8::Uint32>();
+}
+
 v8::MaybeLocal<v8::Array> V8Debugger::internalProperties(
     v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
   v8::Local<v8::Array> properties;
   if (!v8::debug::GetInternalProperties(m_isolate, value).ToLocal(&properties))
     return v8::MaybeLocal<v8::Array>();
+  if (value->IsObject()) {
+    v8::Local<v8::Uint32> id;
+    if (stableObjectId(context, value).ToLocal(&id)) {
+      createDataProperty(
+          context, properties, properties->Length(),
+          toV8StringInternalized(m_isolate, "[[StableObjectId]]"));
+      createDataProperty(context, properties, properties->Length(), id);
+    }
+  }
   if (value->IsFunction()) {
     v8::Local<v8::Function> function = value.As<v8::Function>();
     v8::Local<v8::Object> location;
@@ -1131,7 +1159,7 @@ std::shared_ptr<StackFrame> V8Debugger::symbolize(
   if (it != m_framesCache.end() && !it->second.expired()) {
     return std::shared_ptr<StackFrame>(it->second);
   }
-  std::shared_ptr<StackFrame> frame(new StackFrame(v8Frame));
+  std::shared_ptr<StackFrame> frame(new StackFrame(isolate(), v8Frame));
   // TODO(clemensh): Figure out a way to do this translation only right before
   // sending the stack trace over wire.
   if (v8Frame->IsWasm()) frame->translate(&m_wasmTranslation);
@@ -1169,10 +1197,10 @@ std::pair<int64_t, int64_t> V8Debugger::debuggerIdFor(
 }
 
 void V8Debugger::dumpAsyncTaskStacksStateForTest() {
-//  fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
-//  fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
-//  fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
-//  fprintf(stdout, "\n");
+  fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
+  fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
+  fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
+  fprintf(stdout, "\n");
 }
 
 }  // namespace v8_inspector
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.h
index 1097af363..d8a4f59f5 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-debugger.h
@@ -40,7 +40,7 @@ class V8Debugger : public v8::debug::DebugDelegate,
     public v8::debug::AsyncEventDelegate {
     public:
         V8Debugger(v8::Isolate*, V8InspectorImpl*);
-        ~V8Debugger();
+        ~V8Debugger() override;
 
         bool enabled() const;
         v8::Isolate* isolate() const {
@@ -155,7 +155,8 @@ class V8Debugger : public v8::debug::DebugDelegate,
         void handleProgramBreak(
             v8::Local<v8::Context> pausedContext, v8::Local<v8::Value> exception,
             const std::vector<v8::debug::BreakpointId>& hitBreakpoints,
-            bool isPromiseRejection = false, bool isUncaught = false);
+            v8::debug::ExceptionType exception_type = v8::debug::kException,
+            bool isUncaught = false);
 
         enum ScopeTargetKind {
             FUNCTION,
@@ -191,7 +192,8 @@ class V8Debugger : public v8::debug::DebugDelegate,
             const std::vector<v8::debug::BreakpointId>& break_points_hit) override;
         void ExceptionThrown(v8::Local<v8::Context> paused_context,
                              v8::Local<v8::Value> exception,
-                             v8::Local<v8::Value> promise, bool is_uncaught) override;
+                             v8::Local<v8::Value> promise, bool is_uncaught,
+                             v8::debug::ExceptionType exception_type) override;
         bool IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
                                   const v8::debug::Location& start,
                                   const v8::debug::Location& end) override;
@@ -199,6 +201,9 @@ class V8Debugger : public v8::debug::DebugDelegate,
         int currentContextGroupId();
         bool asyncStepOutOfFunction(int targetContextGroupId, bool onlyAtReturn);
 
+        v8::MaybeLocal<v8::Uint32> stableObjectId(v8::Local<v8::Context>,
+                v8::Local<v8::Value>);
+
         v8::Isolate* m_isolate;
         V8InspectorImpl* m_inspector;
         int m_enableCount;
@@ -255,6 +260,9 @@ class V8Debugger : public v8::debug::DebugDelegate,
 
         std::unique_ptr<TerminateExecutionCallback> m_terminateExecutionCallback;
 
+        uint32_t m_lastStableObjectId = 0;
+        v8::Global<v8::debug::WeakMap> m_stableObjectId;
+
         WasmTranslation m_wasmTranslation;
 
         DISALLOW_COPY_AND_ASSIGN(V8Debugger);
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-dom-agent-impl.cpp b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-dom-agent-impl.cpp
index 0d655323e..6e8f43847 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-dom-agent-impl.cpp
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-dom-agent-impl.cpp
@@ -91,9 +91,9 @@ DispatchResponse V8DOMAgentImpl::getDocument(Maybe<int> in_depth, Maybe<bool> in
             v8::Local<v8::Value> outResult;
 
             if (maybeResult.ToLocal(&outResult)) {
-                auto resultString = ArgConverter::ConvertToUtf16String(outResult->ToString());
+                auto resultString = ArgConverter::ConvertToUtf16String(outResult->ToString(context).ToLocalChecked());
 
-                if (!outResult->ToObject()->Has(context, ArgConverter::ConvertToV8String(isolate, "backendNodeId")).FromMaybe(false)) {
+                if (!outResult->ToObject(context).ToLocalChecked()->Has(context, ArgConverter::ConvertToV8String(isolate, "backendNodeId")).FromMaybe(false)) {
                     // Using an older version of the modules which doesn't set the backendNodeId required property
                     resultString = AddBackendNodeIdProperty(isolate, outResult);
                 }
@@ -365,7 +365,7 @@ std::u16string V8DOMAgentImpl::AddBackendNodeIdProperty(v8::Isolate* isolate, v8
     v8::Local<v8::Value> scriptResult;
     addBackendNodeIdFunction->Call(context, context->Global(), 1, funcArguments).ToLocal(&scriptResult);
 
-    auto resultString = ArgConverter::ConvertToUtf16String(scriptResult->ToString());
+    auto resultString = ArgConverter::ConvertToUtf16String(scriptResult->ToString(context).ToLocalChecked());
     return resultString;
 }
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-heap-profiler-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-heap-profiler-agent-impl.cc
index b876a956b..e50fe0e89 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-heap-profiler-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-heap-profiler-agent-impl.cc
@@ -153,7 +153,7 @@ V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(
       m_state(state),
       m_hasTimer(false) {}
 
-V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl() {}
+V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl() = default;
 
 void V8HeapProfilerAgentImpl::restore() {
   if (m_state->booleanProperty(HeapProfilerAgentState::heapProfilerEnabled,
@@ -335,19 +335,20 @@ Response V8HeapProfilerAgentImpl::startSampling(
 
 namespace {
 std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode>
-buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node) {
+buildSampingHeapProfileNode(v8::Isolate* isolate,
+                            const v8::AllocationProfile::Node* node) {
   auto children = protocol::Array<
       protocol::HeapProfiler::SamplingHeapProfileNode>::create();
   for (const auto* child : node->children)
-    children->addItem(buildSampingHeapProfileNode(child));
+    children->addItem(buildSampingHeapProfileNode(isolate, child));
   size_t selfSize = 0;
   for (const auto& allocation : node->allocations)
     selfSize += allocation.size * allocation.count;
   std::unique_ptr<protocol::Runtime::CallFrame> callFrame =
       protocol::Runtime::CallFrame::create()
-          .setFunctionName(toProtocolString(node->name))
+          .setFunctionName(toProtocolString(isolate, node->name))
           .setScriptId(String16::fromInteger(node->script_id))
-          .setUrl(toProtocolString(node->script_name))
+          .setUrl(toProtocolString(isolate, node->script_name))
           .setLineNumber(node->line_number - 1)
           .setColumnNumber(node->column_number - 1)
           .build();
@@ -383,7 +384,7 @@ Response V8HeapProfilerAgentImpl::getSamplingProfile(
     return Response::Error("V8 sampling heap profiler was not started.");
   v8::AllocationProfile::Node* root = v8Profile->GetRootNode();
   *profile = protocol::HeapProfiler::SamplingHeapProfile::create()
-                 .setHead(buildSampingHeapProfileNode(root))
+                 .setHead(buildSampingHeapProfileNode(m_isolate, root))
                  .build();
   return Response::OK();
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-injected-script-host.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-injected-script-host.cc
index 23f56f93e..d9c1d59aa 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-injected-script-host.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-injected-script-host.cc
@@ -299,7 +299,7 @@ void V8InjectedScriptHost::getInternalPropertiesCallback(
         tryCatch.Reset();
         continue;
       }
-      String16 keyString = toProtocolStringWithTypeCheck(key);
+      String16 keyString = toProtocolStringWithTypeCheck(isolate, key);
       if (keyString.isEmpty() ||
           allowedProperties.find(keyString) == allowedProperties.end())
         continue;
@@ -337,7 +337,8 @@ void V8InjectedScriptHost::bindCallback(
   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
   v8::Local<v8::String> v8groupName =
       info[1]->ToString(context).ToLocalChecked();
-  String16 groupName = toProtocolStringWithTypeCheck(v8groupName);
+  String16 groupName =
+      toProtocolStringWithTypeCheck(info.GetIsolate(), v8groupName);
   int id = injectedScript->bindObject(info[0], groupName);
   info.GetReturnValue().Set(id);
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.cc
index a618321b0..5422b5e12 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.cc
@@ -188,6 +188,17 @@ InspectedContext* V8InspectorImpl::getContext(int contextId) const {
   return getContext(contextGroupId(contextId), contextId);
 }
 
+v8::MaybeLocal<v8::Context> V8InspectorImpl::contextById(
+    int groupId, v8::Maybe<int> contextId) {
+  if (contextId.IsNothing()) {
+    v8::Local<v8::Context> context =
+        client()->ensureDefaultContextInGroup(groupId);
+    return context.IsEmpty() ? v8::MaybeLocal<v8::Context>() : context;
+  }
+  InspectedContext* context = getContext(contextId.FromJust());
+  return context ? context->context() : v8::MaybeLocal<v8::Context>();
+}
+
 void V8InspectorImpl::contextCreated(const V8ContextInfo& info) {
   int contextId = ++m_lastContextId;
   InspectedContext* context = new InspectedContext(this, info, contextId);
@@ -348,7 +359,8 @@ V8Console* V8InspectorImpl::console() {
 }
 
 void V8InspectorImpl::forEachContext(
-    int contextGroupId, std::function<void(InspectedContext*)> callback) {
+    int contextGroupId,
+    const std::function<void(InspectedContext*)>& callback) {
   auto it = m_contexts.find(contextGroupId);
   if (it == m_contexts.end()) return;
   std::vector<int> ids;
@@ -365,7 +377,8 @@ void V8InspectorImpl::forEachContext(
 }
 
 void V8InspectorImpl::forEachSession(
-    int contextGroupId, std::function<void(V8InspectorSessionImpl*)> callback) {
+    int contextGroupId,
+    const std::function<void(V8InspectorSessionImpl*)>& callback) {
   auto it = m_sessions.find(contextGroupId);
   if (it == m_sessions.end()) return;
   std::vector<int> ids;
@@ -400,9 +413,9 @@ V8InspectorImpl::EvaluateScope::~EvaluateScope() {
 class V8InspectorImpl::EvaluateScope::TerminateTask : public v8::Task {
  public:
   TerminateTask(v8::Isolate* isolate, std::shared_ptr<CancelToken> token)
-      : m_isolate(isolate), m_token(token) {}
+      : m_isolate(isolate), m_token(std::move(token)) {}
 
-  void Run() {
+  void Run() override {
     // CancelToken contains m_canceled bool which may be changed from main
     // thread, so lock mutex first.
     v8::base::LockGuard<v8::base::Mutex> lock(&m_token->m_mutex);
@@ -420,8 +433,8 @@ protocol::Response V8InspectorImpl::EvaluateScope::setTimeout(double timeout) {
     return protocol::Response::Error("Execution was terminated");
   }
   m_cancelToken.reset(new CancelToken());
-//  v8::debug::GetCurrentPlatform()->CallDelayedOnWorkerThread(
-//      v8::base::make_unique<TerminateTask>(m_isolate, m_cancelToken), timeout);
+  v8::debug::GetCurrentPlatform()->CallDelayedOnWorkerThread(
+      v8::base::make_unique<TerminateTask>(m_isolate, m_cancelToken), timeout);
   return protocol::Response::OK();
 }
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.h
index acfa421c2..77465b11d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-impl.h
@@ -86,6 +86,8 @@ class V8InspectorImpl : public V8Inspector {
                 const StringView& state) override;
         void contextCreated(const V8ContextInfo&) override;
         void contextDestroyed(v8::Local<v8::Context>) override;
+        v8::MaybeLocal<v8::Context> contextById(int groupId,
+                                                v8::Maybe<int> contextId) override;
         void contextCollected(int contextGroupId, int contextId);
         void resetContextGroup(int contextGroupId) override;
         void idleStarted() override;
@@ -128,9 +130,10 @@ class V8InspectorImpl : public V8Inspector {
         InspectedContext* getContext(int contextId) const;
         V8Console* console();
         void forEachContext(int contextGroupId,
-                            std::function<void(InspectedContext*)> callback);
-        void forEachSession(int contextGroupId,
-                            std::function<void(V8InspectorSessionImpl*)> callback);
+                            const std::function<void(InspectedContext*)>& callback);
+        void forEachSession(
+            int contextGroupId,
+            const std::function<void(V8InspectorSessionImpl*)>& callback);
 
         class EvaluateScope {
             public:
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-platform.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-platform.h
new file mode 100644
index 000000000..02cce8a78
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-platform.h
@@ -0,0 +1,38 @@
+#ifndef V8_INSPECTOR_PLATFORM_H
+#define V8_INSPECTOR_PLATFORM_H
+
+#include "src/libplatform/default-platform.h"
+#include "v8-platform.h"
+
+using namespace std;
+using namespace v8;
+using namespace platform;
+
+namespace v8_inspector {
+
+class V8InspectorPlatform: public DefaultPlatform {
+    public:
+        explicit V8InspectorPlatform(
+            IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
+            unique_ptr<TracingController> tracing_controller = {}) {
+        }
+
+        void CallDelayedOnWorkerThread(unique_ptr<Task> task, double delay_in_seconds) override {
+            DefaultPlatform::CallDelayedOnWorkerThread(move(task), 0);
+        }
+
+        static Platform* CreateDefaultPlatform() {
+            return NewDefaultPlatform().release();
+        }
+    private:
+        static unique_ptr<Platform> NewDefaultPlatform() {
+            unique_ptr<DefaultPlatform> platform(new V8InspectorPlatform());
+            platform->SetThreadPoolSize(0);
+            platform->EnsureBackgroundTaskRunnerInitialized();
+            return move(platform);
+        }
+};
+
+}
+
+#endif //V8_INSPECTOR_PLATFORM_H
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.cc
index 8d7bab9bf..c14f3d9bb 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.cc
@@ -225,6 +225,12 @@ void V8InspectorSessionImpl::sendProtocolNotification(
   m_channel->sendNotification(MessageBuffer::create(std::move(message)));
 }
 
+void V8InspectorSessionImpl::fallThrough(int callId, const String16& method,
+                                         const String16& message) {
+  // There's no other layer to handle the command.
+  UNREACHABLE();
+}
+
 void V8InspectorSessionImpl::flushProtocolNotifications() {
   m_channel->flushProtocolNotifications();
 }
@@ -368,7 +374,15 @@ void V8InspectorSessionImpl::reportAllContexts(V8RuntimeAgentImpl* agent) {
 
 void V8InspectorSessionImpl::dispatchProtocolMessage(
     const StringView& message) {
-  m_dispatcher.dispatch(protocol::StringUtil::parseJSON(message));
+  int callId;
+  String16 method;
+  std::unique_ptr<protocol::Value> parsedMessage =
+      protocol::StringUtil::parseJSON(message);
+  if (m_dispatcher.parseCommand(parsedMessage.get(), &callId, &method)) {
+    // Pass empty string instead of the actual message to save on a conversion.
+    // We're allowed to do so because fall-through is not implemented.
+    m_dispatcher.dispatch(callId, method, std::move(parsedMessage), "");
+  }
 }
 
 std::unique_ptr<StringBuffer> V8InspectorSessionImpl::stateJSON() {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.h
index b5a9c3cf4..3a290fbc3 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-inspector-session-impl.h
@@ -46,7 +46,7 @@ class V8InspectorSessionImpl : public V8InspectorSession,
         static std::unique_ptr<V8InspectorSessionImpl> create(
             V8InspectorImpl*, int contextGroupId, int sessionId,
             V8Inspector::Channel*, const StringView& state);
-        ~V8InspectorSessionImpl();
+        ~V8InspectorSessionImpl() override;
 
         V8InspectorImpl* inspector() const {
             return m_inspector;
@@ -84,6 +84,7 @@ class V8InspectorSessionImpl : public V8InspectorSession,
         V8LogAgentImpl* logAgent() {
             return m_logAgent.get();
         }
+
         int contextGroupId() const {
             return m_contextGroupId;
         }
@@ -147,6 +148,8 @@ class V8InspectorSessionImpl : public V8InspectorSession,
             int callId, std::unique_ptr<protocol::Serializable> message) override;
         void sendProtocolNotification(
             std::unique_ptr<protocol::Serializable> message) override;
+        void fallThrough(int callId, const String16& method,
+                         const String16& message) override;
         void flushProtocolNotifications() override;
 
         int m_contextGroupId;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-profiler-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-profiler-agent-impl.cc
index 59a99d79d..1e16218e1 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-profiler-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-profiler-agent-impl.cc
@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "src/base/atomicops.h"
+#include "src/debug/debug-interface.h"
 #include "src/flags.h"  // TODO(jgruber): Remove include and DEPS entry.
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/string-util.h"
@@ -31,6 +32,15 @@ static const char typeProfileStarted[] = "typeProfileStarted";
 
 namespace {
 
+String16 resourceNameToUrl(V8InspectorImpl* inspector,
+                           v8::Local<v8::String> v8Name) {
+  String16 name = toProtocolString(inspector->isolate(), v8Name);
+  if (!inspector) return name;
+  std::unique_ptr<StringBuffer> url =
+      inspector->client()->resourceNameToUrl(toStringView(name));
+  return url ? toString16(url->string()) : name;
+}
+
 std::unique_ptr<protocol::Array<protocol::Profiler::PositionTickInfo>>
 buildInspectorObjectForPositionTicks(const v8::CpuProfileNode* node) {
   unsigned lineCount = node->GetHitLineCount();
@@ -51,13 +61,14 @@ buildInspectorObjectForPositionTicks(const v8::CpuProfileNode* node) {
 }
 
 std::unique_ptr<protocol::Profiler::ProfileNode> buildInspectorObjectFor(
-    v8::Isolate* isolate, const v8::CpuProfileNode* node) {
+    V8InspectorImpl* inspector, const v8::CpuProfileNode* node) {
+  v8::Isolate* isolate = inspector->isolate();
   v8::HandleScope handleScope(isolate);
   auto callFrame =
       protocol::Runtime::CallFrame::create()
-          .setFunctionName(toProtocolString(node->GetFunctionName()))
+          .setFunctionName(toProtocolString(isolate, node->GetFunctionName()))
           .setScriptId(String16::fromInteger(node->GetScriptId()))
-          .setUrl(toProtocolString(node->GetScriptResourceName()))
+          .setUrl(resourceNameToUrl(inspector, node->GetScriptResourceName()))
           .setLineNumber(node->GetLineNumber() - 1)
           .setColumnNumber(node->GetColumnNumber() - 1)
           .build();
@@ -107,18 +118,19 @@ std::unique_ptr<protocol::Array<int>> buildInspectorObjectForTimestamps(
   return array;
 }
 
-void flattenNodesTree(v8::Isolate* isolate, const v8::CpuProfileNode* node,
+void flattenNodesTree(V8InspectorImpl* inspector,
+                      const v8::CpuProfileNode* node,
                       protocol::Array<protocol::Profiler::ProfileNode>* list) {
-  list->addItem(buildInspectorObjectFor(isolate, node));
+  list->addItem(buildInspectorObjectFor(inspector, node));
   const int childrenCount = node->GetChildrenCount();
   for (int i = 0; i < childrenCount; i++)
-    flattenNodesTree(isolate, node->GetChild(i), list);
+    flattenNodesTree(inspector, node->GetChild(i), list);
 }
 
 std::unique_ptr<protocol::Profiler::Profile> createCPUProfile(
-    v8::Isolate* isolate, v8::CpuProfile* v8profile) {
+    V8InspectorImpl* inspector, v8::CpuProfile* v8profile) {
   auto nodes = protocol::Array<protocol::Profiler::ProfileNode>::create();
-  flattenNodesTree(isolate, v8profile->GetTopDownRoot(), nodes.get());
+  flattenNodesTree(inspector, v8profile->GetTopDownRoot(), nodes.get());
   return protocol::Profiler::Profile::create()
       .setNodes(std::move(nodes))
       .setStartTime(static_cast<double>(v8profile->GetStartTime()))
@@ -320,11 +332,12 @@ std::unique_ptr<protocol::Profiler::CoverageRange> createCoverageRange(
 }
 
 Response coverageToProtocol(
-    v8::Isolate* isolate, const v8::debug::Coverage& coverage,
+    V8InspectorImpl* inspector, const v8::debug::Coverage& coverage,
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
         out_result) {
   std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>> result =
       protocol::Array<protocol::Profiler::ScriptCoverage>::create();
+  v8::Isolate* isolate = inspector->isolate();
   for (size_t i = 0; i < coverage.ScriptCount(); i++) {
     v8::debug::Coverage::ScriptData script_data = coverage.GetScriptData(i);
     v8::Local<v8::debug::Script> script = script_data.GetScript();
@@ -354,6 +367,7 @@ Response coverageToProtocol(
       functions->addItem(
           protocol::Profiler::FunctionCoverage::create()
               .setFunctionName(toProtocolString(
+                  isolate,
                   function_data.Name().FromMaybe(v8::Local<v8::String>())))
               .setRanges(std::move(ranges))
               .setIsBlockCoverage(function_data.HasBlockCoverage())
@@ -361,8 +375,10 @@ Response coverageToProtocol(
     }
     String16 url;
     v8::Local<v8::String> name;
-    if (script->Name().ToLocal(&name) || script->SourceURL().ToLocal(&name)) {
-      url = toProtocolString(name);
+    if (script->SourceURL().ToLocal(&name) && name->Length()) {
+      url = toProtocolString(isolate, name);
+    } else if (script->Name().ToLocal(&name) && name->Length()) {
+      url = resourceNameToUrl(inspector, name);
     }
     result->addItem(protocol::Profiler::ScriptCoverage::create()
                         .setScriptId(String16::fromInteger(script->Id()))
@@ -384,7 +400,7 @@ Response V8ProfilerAgentImpl::takePreciseCoverage(
   }
   v8::HandleScope handle_scope(m_isolate);
   v8::debug::Coverage coverage = v8::debug::Coverage::CollectPrecise(m_isolate);
-  return coverageToProtocol(m_isolate, coverage, out_result);
+  return coverageToProtocol(m_session->inspector(), coverage, out_result);
 }
 
 Response V8ProfilerAgentImpl::getBestEffortCoverage(
@@ -393,15 +409,16 @@ Response V8ProfilerAgentImpl::getBestEffortCoverage(
   v8::HandleScope handle_scope(m_isolate);
   v8::debug::Coverage coverage =
       v8::debug::Coverage::CollectBestEffort(m_isolate);
-  return coverageToProtocol(m_isolate, coverage, out_result);
+  return coverageToProtocol(m_session->inspector(), coverage, out_result);
 }
 
 namespace {
 std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>>
-typeProfileToProtocol(v8::Isolate* isolate,
+typeProfileToProtocol(V8InspectorImpl* inspector,
                       const v8::debug::TypeProfile& type_profile) {
   std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>>
       result = protocol::Array<protocol::Profiler::ScriptTypeProfile>::create();
+  v8::Isolate* isolate = inspector->isolate();
   for (size_t i = 0; i < type_profile.ScriptCount(); i++) {
     v8::debug::TypeProfile::ScriptData script_data =
         type_profile.GetScriptData(i);
@@ -414,10 +431,11 @@ typeProfileToProtocol(v8::Isolate* isolate,
       std::unique_ptr<protocol::Array<protocol::Profiler::TypeObject>> types =
           protocol::Array<protocol::Profiler::TypeObject>::create();
       for (const auto& type : entry.Types()) {
-        types->addItem(protocol::Profiler::TypeObject::create()
-                           .setName(toProtocolString(
-                               type.FromMaybe(v8::Local<v8::String>())))
-                           .build());
+        types->addItem(
+            protocol::Profiler::TypeObject::create()
+                .setName(toProtocolString(
+                    isolate, type.FromMaybe(v8::Local<v8::String>())))
+                .build());
       }
       entries->addItem(protocol::Profiler::TypeProfileEntry::create()
                            .setOffset(entry.SourcePosition())
@@ -426,8 +444,10 @@ typeProfileToProtocol(v8::Isolate* isolate,
     }
     String16 url;
     v8::Local<v8::String> name;
-    if (script->Name().ToLocal(&name) || script->SourceURL().ToLocal(&name)) {
-      url = toProtocolString(name);
+    if (script->SourceURL().ToLocal(&name) && name->Length()) {
+      url = toProtocolString(isolate, name);
+    } else if (script->Name().ToLocal(&name) && name->Length()) {
+      url = resourceNameToUrl(inspector, name);
     }
     result->addItem(protocol::Profiler::ScriptTypeProfile::create()
                         .setScriptId(String16::fromInteger(script->Id()))
@@ -462,7 +482,7 @@ Response V8ProfilerAgentImpl::takeTypeProfile(
   v8::HandleScope handle_scope(m_isolate);
   v8::debug::TypeProfile type_profile =
       v8::debug::TypeProfile::Collect(m_isolate);
-  *out_result = typeProfileToProtocol(m_isolate, type_profile);
+  *out_result = typeProfileToProtocol(m_session->inspector(), type_profile);
   return Response::OK();
 }
 
@@ -491,7 +511,7 @@ std::unique_ptr<protocol::Profiler::Profile> V8ProfilerAgentImpl::stopProfiling(
       m_profiler->StopProfiling(toV8String(m_isolate, title));
   std::unique_ptr<protocol::Profiler::Profile> result;
   if (profile) {
-    if (serialize) result = createCPUProfile(m_isolate, profile);
+    if (serialize) result = createCPUProfile(m_session->inspector(), profile);
     profile->Delete();
   }
   --m_startedProfilesCount;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.cc
index 0bab4364c..5f43d84e2 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.cc
@@ -32,7 +32,7 @@ V8Regex::V8Regex(V8InspectorImpl* inspector, const String16& pattern,
           .ToLocal(&regex))
     m_regex.Reset(isolate, regex);
   else if (tryCatch.HasCaught())
-    m_errorMessage = toProtocolString(tryCatch.Message()->Get());
+    m_errorMessage = toProtocolString(isolate, tryCatch.Message()->Get());
   else
     m_errorMessage = "Internal error";
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.h
index 77f9d03d0..710c0c5b8 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-regex.h
@@ -20,7 +20,8 @@ class V8Regex {
     public:
         V8Regex(V8InspectorImpl*, const String16&, bool caseSensitive,
                 bool multiline = false);
-        int match(const String16&, int startFrom = 0, int* matchLength = 0) const;
+        int match(const String16&, int startFrom = 0,
+                  int* matchLength = nullptr) const;
         bool isValid() const {
             return !m_regex.IsEmpty();
         }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-runtime-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-runtime-agent-impl.cc
index 31111add1..9e3697cf9 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-runtime-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-runtime-agent-impl.cc
@@ -226,7 +226,7 @@ V8RuntimeAgentImpl::V8RuntimeAgentImpl(
       m_inspector(session->inspector()),
       m_enabled(false) {}
 
-V8RuntimeAgentImpl::~V8RuntimeAgentImpl() {}
+V8RuntimeAgentImpl::~V8RuntimeAgentImpl() = default;
 
 void V8RuntimeAgentImpl::evaluate(
     const String16& expression, Maybe<String16> objectGroup,
@@ -426,7 +426,8 @@ Response V8RuntimeAgentImpl::getProperties(
     if (!response.isSuccess()) return response;
     propertiesProtocolArray->addItem(
         InternalPropertyDescriptor::create()
-            .setName(toProtocolString(name.As<v8::String>()))
+            .setName(
+                toProtocolString(m_inspector->isolate(), name.As<v8::String>()))
             .setValue(std::move(wrappedValue))
             .build());
   }
@@ -622,7 +623,8 @@ Response V8RuntimeAgentImpl::globalLexicalScopeNames(
   v8::debug::GlobalLexicalScopeNames(scope.context(), &names);
   *outNames = protocol::Array<String16>::create();
   for (size_t i = 0; i < names.Size(); ++i) {
-    (*outNames)->addItem(toProtocolString(names.Get(i)));
+    (*outNames)->addItem(
+        toProtocolString(m_inspector->isolate(), names.Get(i)));
   }
   return Response::OK();
 }
@@ -690,8 +692,10 @@ void V8RuntimeAgentImpl::bindingCallback(
   int contextId = InspectedContext::contextId(isolate->GetCurrentContext());
   int contextGroupId = inspector->contextGroupId(contextId);
 
-  String16 name = toProtocolString(v8::Local<v8::String>::Cast(info.Data()));
-  String16 payload = toProtocolString(v8::Local<v8::String>::Cast(info[0]));
+  String16 name =
+      toProtocolString(isolate, v8::Local<v8::String>::Cast(info.Data()));
+  String16 payload =
+      toProtocolString(isolate, v8::Local<v8::String>::Cast(info[0]));
 
   inspector->forEachSession(
       contextGroupId,
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-schema-agent-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-schema-agent-impl.cc
index d7b6cdcb0..07bbd35d9 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-schema-agent-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-schema-agent-impl.cc
@@ -14,7 +14,7 @@ V8SchemaAgentImpl::V8SchemaAgentImpl(V8InspectorSessionImpl* session,
                                      protocol::DictionaryValue* state)
     : m_session(session), m_frontend(frontendChannel) {}
 
-V8SchemaAgentImpl::~V8SchemaAgentImpl() {}
+V8SchemaAgentImpl::~V8SchemaAgentImpl() = default;
 
 Response V8SchemaAgentImpl::getDomains(
     std::unique_ptr<protocol::Array<protocol::Schema::Domain>>* result) {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.cc
index 75293c59a..ae41344a7 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 #include "src/inspector/v8-debugger.h"
+#include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/wasm-translation.h"
 
 namespace v8_inspector {
@@ -27,7 +28,8 @@ std::vector<std::shared_ptr<StackFrame>> toFramesVector(
   int frameCount = std::min(v8StackTrace->GetFrameCount(), maxStackSize);
   std::vector<std::shared_ptr<StackFrame>> frames(frameCount);
   for (int i = 0; i < frameCount; ++i) {
-    frames[i] = debugger->symbolize(v8StackTrace->GetFrame(i));
+    frames[i] =
+        debugger->symbolize(v8StackTrace->GetFrame(debugger->isolate(), i));
   }
   return frames;
 }
@@ -73,7 +75,10 @@ std::unique_ptr<protocol::Runtime::StackTrace> buildInspectorObjectCommon(
   std::unique_ptr<protocol::Array<protocol::Runtime::CallFrame>>
       inspectorFrames = protocol::Array<protocol::Runtime::CallFrame>::create();
   for (size_t i = 0; i < frames.size(); i++) {
-    inspectorFrames->addItem(frames[i]->buildInspectorObject());
+    V8InspectorClient* client = nullptr;
+    if (debugger && debugger->inspector())
+      client = debugger->inspector()->client();
+    inspectorFrames->addItem(frames[i]->buildInspectorObject(client));
   }
   std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
       protocol::Runtime::StackTrace::create()
@@ -112,12 +117,15 @@ V8StackTraceId::V8StackTraceId(uintptr_t id,
 
 bool V8StackTraceId::IsInvalid() const { return !id; }
 
-StackFrame::StackFrame(v8::Local<v8::StackFrame> v8Frame)
-    : m_functionName(toProtocolString(v8Frame->GetFunctionName())),
+StackFrame::StackFrame(v8::Isolate* isolate, v8::Local<v8::StackFrame> v8Frame)
+    : m_functionName(toProtocolString(isolate, v8Frame->GetFunctionName())),
       m_scriptId(String16::fromInteger(v8Frame->GetScriptId())),
-      m_sourceURL(toProtocolString(v8Frame->GetScriptNameOrSourceURL())),
+      m_sourceURL(
+          toProtocolString(isolate, v8Frame->GetScriptNameOrSourceURL())),
       m_lineNumber(v8Frame->GetLineNumber() - 1),
-      m_columnNumber(v8Frame->GetColumn() - 1) {
+      m_columnNumber(v8Frame->GetColumn() - 1),
+      m_hasSourceURLComment(v8Frame->GetScriptName() !=
+                            v8Frame->GetScriptNameOrSourceURL()) {
   DCHECK_NE(v8::Message::kNoLineNumberInfo, m_lineNumber + 1);
   DCHECK_NE(v8::Message::kNoColumnInfo, m_columnNumber + 1);
 }
@@ -137,12 +145,20 @@ int StackFrame::lineNumber() const { return m_lineNumber; }
 
 int StackFrame::columnNumber() const { return m_columnNumber; }
 
-std::unique_ptr<protocol::Runtime::CallFrame> StackFrame::buildInspectorObject()
-    const {
+std::unique_ptr<protocol::Runtime::CallFrame> StackFrame::buildInspectorObject(
+    V8InspectorClient* client) const {
+  String16 frameUrl = m_sourceURL;
+  if (client && !m_hasSourceURLComment && frameUrl.length() > 0) {
+    std::unique_ptr<StringBuffer> url =
+        client->resourceNameToUrl(toStringView(m_sourceURL));
+    if (url) {
+      frameUrl = toString16(url->string());
+    }
+  }
   return protocol::Runtime::CallFrame::create()
       .setFunctionName(m_functionName)
       .setScriptId(m_scriptId)
-      .setUrl(m_sourceURL)
+      .setUrl(frameUrl)
       .setLineNumber(m_lineNumber)
       .setColumnNumber(m_columnNumber)
       .build();
@@ -207,10 +223,10 @@ V8StackTraceImpl::V8StackTraceImpl(
     const V8StackTraceId& externalParent)
     : m_frames(std::move(frames)),
       m_maxAsyncDepth(maxAsyncDepth),
-      m_asyncParent(asyncParent),
+      m_asyncParent(std::move(asyncParent)),
       m_externalParent(externalParent) {}
 
-V8StackTraceImpl::~V8StackTraceImpl() {}
+V8StackTraceImpl::~V8StackTraceImpl() = default;
 
 std::unique_ptr<V8StackTrace> V8StackTraceImpl::clone() {
   return std::unique_ptr<V8StackTrace>(new V8StackTraceImpl(
@@ -376,7 +392,7 @@ AsyncStackTrace::AsyncStackTrace(
       m_suspendedTaskId(nullptr),
       m_description(description),
       m_frames(std::move(frames)),
-      m_asyncParent(asyncParent),
+      m_asyncParent(std::move(asyncParent)),
       m_externalParent(externalParent) {
   DCHECK(m_contextGroupId || (!externalParent.IsInvalid() && m_frames.empty()));
 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.h b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.h
index 7b961f115..54621e6ec 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-stack-trace-impl.h
@@ -23,7 +23,7 @@ struct V8StackTraceId;
 
 class StackFrame {
     public:
-        explicit StackFrame(v8::Local<v8::StackFrame> frame);
+        explicit StackFrame(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame);
         ~StackFrame() = default;
 
         void translate(WasmTranslation* wasmTranslation);
@@ -33,7 +33,8 @@ class StackFrame {
         const String16& sourceURL() const;
         int lineNumber() const;    // 0-based.
         int columnNumber() const;  // 0-based.
-        std::unique_ptr<protocol::Runtime::CallFrame> buildInspectorObject() const;
+        std::unique_ptr<protocol::Runtime::CallFrame> buildInspectorObject(
+            V8InspectorClient* client) const;
         bool isEqual(StackFrame* frame) const;
 
     private:
@@ -42,6 +43,7 @@ class StackFrame {
         String16 m_sourceURL;
         int m_lineNumber;    // 0-based.
         int m_columnNumber;  // 0-based.
+        bool m_hasSourceURLComment;
 };
 
 class V8StackTraceImpl : public V8StackTrace {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-value-utils.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-value-utils.cc
index 3835f34f6..feaffd36d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-value-utils.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/v8-value-utils.cc
@@ -39,8 +39,8 @@ protocol::Response toProtocolValue(v8::Local<v8::Context> context,
     return Response::OK();
   }
   if (value->IsString()) {
-    *result =
-        protocol::StringValue::create(toProtocolString(value.As<v8::String>()));
+    *result = protocol::StringValue::create(
+        toProtocolString(context->GetIsolate(), value.As<v8::String>()));
     return Response::OK();
   }
   if (value->IsArray()) {
@@ -90,8 +90,9 @@ protocol::Response toProtocolValue(v8::Local<v8::Context> context,
       Response response =
           toProtocolValue(context, property, maxDepth, &propertyValue);
       if (!response.isSuccess()) return response;
-      jsonObject->setValue(toProtocolString(propertyName),
-                           std::move(propertyValue));
+      jsonObject->setValue(
+          toProtocolString(context->GetIsolate(), propertyName),
+          std::move(propertyValue));
     }
     *result = std::move(jsonObject);
     return Response::OK();
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/wasm-translation.cc b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/wasm-translation.cc
index 4754af544..c5d1f8c6a 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/wasm-translation.cc
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/inspector/wasm-translation.cc
@@ -62,7 +62,7 @@ class WasmTranslation::TranslatorImpl {
     TransLocation(WasmTranslation* translation, String16 script_id, int line,
                   int column)
         : translation(translation),
-          script_id(script_id),
+          script_id(std::move(script_id)),
           line(line),
           column(column) {}
   };
@@ -74,7 +74,7 @@ class WasmTranslation::TranslatorImpl {
                                                             int index) = 0;
   virtual const String16 GetHash(v8::Isolate*, int index) = 0;
 
-  virtual ~TranslatorImpl() {}
+  virtual ~TranslatorImpl() = default;
 
   class RawTranslator;
   class DisassemblingTranslator;
@@ -219,7 +219,8 @@ class WasmTranslation::TranslatorImpl::DisassemblingTranslator
  private:
   String16 GetFakeScriptUrl(v8::Isolate* isolate, int func_index) {
     v8::Local<v8::debug::WasmScript> script = script_.Get(isolate);
-    String16 script_name = toProtocolString(script->Name().ToLocalChecked());
+    String16 script_name =
+        toProtocolString(isolate, script->Name().ToLocalChecked());
     int numFunctions = script->NumFunctions();
     int numImported = script->NumImportedFunctions();
     String16Builder builder;
@@ -237,7 +238,7 @@ class WasmTranslation::TranslatorImpl::DisassemblingTranslator
     return builder.toString();
   }
 
-  String16 GetFakeScriptId(const String16 script_id, int func_index) {
+  String16 GetFakeScriptId(const String16& script_id, int func_index) {
     return String16::concat(script_id, '-', String16::fromInteger(func_index));
   }
   String16 GetFakeScriptId(const TransLocation* loc) {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/libplatform/default-platform.h b/test-app/runtime/src/main/cpp/v8_inspector/src/libplatform/default-platform.h
new file mode 100644
index 000000000..668b884bb
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/libplatform/default-platform.h
@@ -0,0 +1,96 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_LIBPLATFORM_DEFAULT_PLATFORM_H_
+#define V8_LIBPLATFORM_DEFAULT_PLATFORM_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <queue>
+#include <vector>
+
+#include "include/libplatform/libplatform-export.h"
+#include "include/libplatform/libplatform.h"
+#include "include/libplatform/v8-tracing.h"
+#include "include/v8-platform.h"
+#include "src/base/compiler-specific.h"
+#include "src/base/macros.h"
+#include "src/base/platform/mutex.h"
+#include "src/base/platform/time.h"
+
+namespace v8 {
+namespace platform {
+
+class Thread;
+class WorkerThread;
+class DefaultForegroundTaskRunner;
+class DefaultWorkerThreadsTaskRunner;
+class DefaultPageAllocator;
+
+class V8_PLATFORM_EXPORT DefaultPlatform : public NON_EXPORTED_BASE(Platform) {
+    public:
+        explicit DefaultPlatform(
+            IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
+            std::unique_ptr<v8::TracingController> tracing_controller = {});
+
+        ~DefaultPlatform() override;
+
+        void SetThreadPoolSize(int thread_pool_size);
+
+        void EnsureBackgroundTaskRunnerInitialized();
+
+        bool PumpMessageLoop(
+            v8::Isolate* isolate,
+            MessageLoopBehavior behavior = MessageLoopBehavior::kDoNotWait);
+
+        void RunIdleTasks(v8::Isolate* isolate, double idle_time_in_seconds);
+
+        void SetTracingController(
+            std::unique_ptr<v8::TracingController> tracing_controller);
+
+        using TimeFunction = double (*)();
+
+        void SetTimeFunctionForTesting(TimeFunction time_function);
+
+        // v8::Platform implementation.
+        int NumberOfWorkerThreads() override;
+        std::shared_ptr<TaskRunner> GetForegroundTaskRunner(
+            v8::Isolate* isolate) override;
+        void CallOnWorkerThread(std::unique_ptr<Task> task) override;
+        void CallDelayedOnWorkerThread(std::unique_ptr<Task> task,
+                                       double delay_in_seconds) override;
+        void CallOnForegroundThread(v8::Isolate* isolate, Task* task) override;
+        void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
+                                           double delay_in_seconds) override;
+        void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) override;
+        bool IdleTasksEnabled(Isolate* isolate) override;
+        double MonotonicallyIncreasingTime() override;
+        double CurrentClockTimeMillis() override;
+        v8::TracingController* GetTracingController() override;
+        StackTracePrinter GetStackTracePrinter() override;
+        v8::PageAllocator* GetPageAllocator() override;
+
+    private:
+        static const int kMaxThreadPoolSize;
+
+        base::Mutex lock_;
+        int thread_pool_size_;
+        IdleTaskSupport idle_task_support_;
+        std::shared_ptr<DefaultWorkerThreadsTaskRunner> worker_threads_task_runner_;
+        std::map<v8::Isolate*, std::shared_ptr<DefaultForegroundTaskRunner>>
+                foreground_task_runner_map_;
+
+        std::unique_ptr<TracingController> tracing_controller_;
+        std::unique_ptr<PageAllocator> page_allocator_;
+
+        TimeFunction time_function_for_testing_;
+        DISALLOW_COPY_AND_ASSIGN(DefaultPlatform);
+};
+
+}  // namespace platform
+}  // namespace v8
+
+
+#endif  // V8_LIBPLATFORM_DEFAULT_PLATFORM_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/splay-tree.h b/test-app/runtime/src/main/cpp/v8_inspector/src/splay-tree.h
index 288cfe5bb..7749ee865 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/splay-tree.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/splay-tree.h
@@ -144,7 +144,7 @@ class SplayTree {
 
         // A locator provides access to a node in the tree without actually
         // exposing the node.
-        class Locator BASE_EMBEDDED {
+        class Locator {
             public:
                 explicit Locator(Node* node) : node_(node) { }
                 Locator() : node_(nullptr) {}
@@ -185,8 +185,8 @@ class SplayTree {
         // Removes root_ node.
         void RemoveRootNode(const Key& key);
 
-        template<class Callback>
-        class NodeToPairAdaptor BASE_EMBEDDED {
+        template <class Callback>
+        class NodeToPairAdaptor {
             public:
                 explicit NodeToPairAdaptor(Callback* callback)
                     : callback_(callback) { }
@@ -200,9 +200,9 @@ class SplayTree {
                 DISALLOW_COPY_AND_ASSIGN(NodeToPairAdaptor);
         };
 
-        class NodeDeleter BASE_EMBEDDED {
+        class NodeDeleter {
             public:
-                NodeDeleter() { }
+                NodeDeleter() = default;
                 void Call(Node* node) {
                     AllocationPolicy::Delete(node);
                 }
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/third_party/utf8-decoder/utf8-decoder.h b/test-app/runtime/src/main/cpp/v8_inspector/src/third_party/utf8-decoder/utf8-decoder.h
index b473e924e..6f09a50cd 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/third_party/utf8-decoder/utf8-decoder.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/third_party/utf8-decoder/utf8-decoder.h
@@ -67,7 +67,6 @@ static inline void Decode(uint8_t byte, State* state, uint32_t* buffer) {
         0,  0,  36, 36, 0,  0,  0,  0,  0,  0, 0,  0,   // 4-byte mid/high = 96
     };
 
-    DCHECK_NE(*state, State::kReject);
     uint8_t type = transitions[byte];
     *state = static_cast<State>(states[*state + type]);
     *buffer = (*buffer << 6) | (byte & (0x7F >> (type >> 1)));
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/tracing/trace-event.h b/test-app/runtime/src/main/cpp/v8_inspector/src/tracing/trace-event.h
index 9ce468d44..5ac99c1fd 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/tracing/trace-event.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/tracing/trace-event.h
@@ -50,7 +50,7 @@ enum CategoryGroupEnabledFlags {
   trace_event_internal::TraceID::WithScope(scope, id)
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
-  *INTERNAL_TRACE_EVENT_UID(category_group_enabled) &                    \
+  TRACE_EVENT_API_LOAD_CATEGORY_GROUP_ENABLED() &                        \
       (kEnabledForRecording_CategoryGroupEnabledFlags |                  \
        kEnabledForEventCallback_CategoryGroupEnabledFlags)
 
@@ -127,6 +127,9 @@ enum CategoryGroupEnabledFlags {
 #define TRACE_EVENT_API_ATOMIC_LOAD(var) v8::base::Relaxed_Load(&(var))
 #define TRACE_EVENT_API_ATOMIC_STORE(var, value) \
   v8::base::Relaxed_Store(&(var), (value))
+#define TRACE_EVENT_API_LOAD_CATEGORY_GROUP_ENABLED()                \
+  v8::base::Relaxed_Load(reinterpret_cast<const v8::base::Atomic8*>( \
+      INTERNAL_TRACE_EVENT_UID(category_group_enabled)))
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -175,7 +178,7 @@ enum CategoryGroupEnabledFlags {
           v8::internal::tracing::kGlobalScope, v8::internal::tracing::kNoId, \
           v8::internal::tracing::kNoId, flags, ##__VA_ARGS__);               \
     }                                                                        \
-  } while (0)
+  } while (false)
 
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
@@ -227,7 +230,7 @@ enum CategoryGroupEnabledFlags {
           trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),         \
           v8::internal::tracing::kNoId, trace_event_flags, ##__VA_ARGS__);     \
     }                                                                          \
-  } while (0)
+  } while (false)
 
 // Adds a trace event with a given timestamp.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category_group, name, \
@@ -240,7 +243,7 @@ enum CategoryGroupEnabledFlags {
           v8::internal::tracing::kGlobalScope, v8::internal::tracing::kNoId, \
           v8::internal::tracing::kNoId, flags, timestamp, ##__VA_ARGS__);    \
     }                                                                        \
-  } while (0)
+  } while (false)
 
 // Adds a trace event with a given id and timestamp.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP(                        \
@@ -257,7 +260,7 @@ enum CategoryGroupEnabledFlags {
           v8::internal::tracing::kNoId, trace_event_flags, timestamp,          \
           ##__VA_ARGS__);                                                      \
     }                                                                          \
-  } while (0)
+  } while (false)
 
 // Adds a trace event with a given id, thread_id, and timestamp. This redirects
 // to INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP as we presently do not care
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-cache.h b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-cache.h
index c01e96c51..4b1b27062 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-cache.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-cache.h
@@ -16,7 +16,7 @@ namespace internal {
 // Caching predicates used by scanners.
 class UnicodeCache {
     public:
-        UnicodeCache() {}
+        UnicodeCache() = default;
         typedef unibrow::Utf8Decoder<512> Utf8Decoder;
 
         StaticResource<Utf8Decoder>* utf8_decoder() {
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-decoder.h b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-decoder.h
index 70f27586b..7a2933e9d 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-decoder.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode-decoder.h
@@ -87,7 +87,7 @@ class V8_EXPORT_PRIVATE Utf8DecoderBase {
 template <size_t kBufferSize>
 class Utf8Decoder : public Utf8DecoderBase {
     public:
-        inline Utf8Decoder() {}
+        inline Utf8Decoder() = default;
         explicit inline Utf8Decoder(const v8::internal::Vector<const char>& stream);
         inline void Reset(const v8::internal::Vector<const char>& stream);
         inline size_t WriteUtf16(
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode.h b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode.h
index a919ec718..f4cbd1223 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/unicode.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/unicode.h
@@ -28,7 +28,7 @@ const int kMaxMappingSize = 4;
 template <class T, int size = 256>
 class Predicate {
     public:
-        inline Predicate() { }
+        inline Predicate() = default;
         inline bool get(uchar c);
 
     private:
@@ -72,7 +72,7 @@ class Predicate {
 template <class T, int size = 256>
 class Mapping {
     public:
-        inline Mapping() { }
+        inline Mapping() = default;
         inline int get(uchar c, uchar n, uchar* result);
     private:
         friend class Test;
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/utils.h b/test-app/runtime/src/main/cpp/v8_inspector/src/utils.h
index ca82df3d3..a9b120591 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/utils.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/utils.h
@@ -1,3 +1,4 @@
+
 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
@@ -9,6 +10,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <cmath>
+#include <string>
 #include <type_traits>
 
 #include "include/v8.h"
@@ -63,6 +65,20 @@ inline bool CStringEquals(const char* s1, const char* s2) {
     return (s1 == s2) || (s1 != nullptr && s2 != nullptr && strcmp(s1, s2) == 0);
 }
 
+// Checks if value is in range [lower_limit, higher_limit] using a single
+// branch.
+template <typename T, typename U>
+inline bool IsInRange(T value, U lower_limit, U higher_limit) {
+    DCHECK_LE(lower_limit, higher_limit);
+    STATIC_ASSERT(sizeof(U) <= sizeof(T));
+    typedef typename std::make_unsigned<T>::type unsigned_T;
+    // Use static_cast to support enum classes.
+    return static_cast<unsigned_T>(static_cast<unsigned_T>(value) -
+                                   static_cast<unsigned_T>(lower_limit)) <=
+           static_cast<unsigned_T>(static_cast<unsigned_T>(higher_limit) -
+                                   static_cast<unsigned_T>(lower_limit));
+}
+
 // X must be a power of 2.  Returns the number of trailing zeros.
 template <typename T,
           typename = typename std::enable_if<std::is_integral<T>::value>::type>
@@ -162,13 +178,11 @@ inline bool IsAligned(T value, U alignment) {
     return (value & (alignment - 1)) == 0;
 }
 
-
-// Returns true if (addr + offset) is aligned.
+// Returns true if {addr + offset} is aligned.
 inline bool IsAddressAligned(Address addr,
                              intptr_t alignment,
                              int offset = 0) {
-    intptr_t offs = OffsetFrom(addr + offset);
-    return IsAligned(offs, alignment);
+    return IsAligned(addr + offset, alignment);
 }
 
 
@@ -506,10 +520,9 @@ class BitSetComputer {
 static const uint64_t kZeroHashSeed = 0;
 
 // Thomas Wang, Integer Hash Functions.
-// http://www.concentric.net/~Ttwang/tech/inthash.htm
-inline uint32_t ComputeIntegerHash(uint32_t key, uint64_t seed) {
+// http://www.concentric.net/~Ttwang/tech/inthash.htm`
+inline uint32_t ComputeUnseededHash(uint32_t key) {
     uint32_t hash = key;
-    hash = hash ^ static_cast<uint32_t>(seed);
     hash = ~hash + (hash << 15);  // hash = (hash << 15) - hash - 1;
     hash = hash ^ (hash >> 12);
     hash = hash + (hash << 2);
@@ -519,10 +532,6 @@ inline uint32_t ComputeIntegerHash(uint32_t key, uint64_t seed) {
     return hash & 0x3fffffff;
 }
 
-inline uint32_t ComputeIntegerHash(uint32_t key) {
-    return ComputeIntegerHash(key, kZeroHashSeed);
-}
-
 inline uint32_t ComputeLongHash(uint64_t key) {
     uint64_t hash = key;
     hash = ~hash + (hash << 18);  // hash = (hash << 18) - hash - 1;
@@ -531,24 +540,27 @@ inline uint32_t ComputeLongHash(uint64_t key) {
     hash = hash ^ (hash >> 11);
     hash = hash + (hash << 6);
     hash = hash ^ (hash >> 22);
-    return static_cast<uint32_t>(hash);
+    return static_cast<uint32_t>(hash & 0x3fffffff);
 }
 
+inline uint32_t ComputeSeededHash(uint32_t key, uint64_t seed) {
+    return ComputeLongHash(static_cast<uint64_t>(key) ^ seed);
+}
 
 inline uint32_t ComputePointerHash(void* ptr) {
-    return ComputeIntegerHash(
+    return ComputeUnseededHash(
                static_cast<uint32_t>(reinterpret_cast<intptr_t>(ptr)));
 }
 
 inline uint32_t ComputeAddressHash(Address address) {
-    return ComputeIntegerHash(static_cast<uint32_t>(address & 0xFFFFFFFFul));
+    return ComputeUnseededHash(static_cast<uint32_t>(address & 0xFFFFFFFFul));
 }
 
 // ----------------------------------------------------------------------------
 // Generated memcpy/memmove
 
 // Initializes the codegen support that depends on CPU features.
-void init_memcopy_functions(Isolate* isolate);
+void init_memcopy_functions();
 
 #if defined(V8_TARGET_ARCH_IA32)
 // Limit below which the extra overhead of the MemCopy function is likely
@@ -1200,12 +1212,6 @@ inline void Flush() {
 char* ReadLine(const char* prompt);
 
 
-// Read and return the raw bytes in a file. the size of the buffer is returned
-// in size.
-// The returned buffer must be freed by the caller.
-byte* ReadBytes(const char* filename, int* size, bool verbose = true);
-
-
 // Append size chars from str to the file given by filename.
 // The file is overwritten. Returns the number of chars written.
 int AppendChars(const char* filename,
@@ -1351,16 +1357,11 @@ inline void MemsetPointer(T** dest, U* value, int counter) {
 #undef STOS
 }
 
-
-// Simple support to read a file into a 0-terminated C-string.
-// The returned buffer must be freed by the caller.
+// Simple support to read a file into std::string.
 // On return, *exits tells whether the file existed.
-V8_EXPORT_PRIVATE Vector<const char> ReadFile(const char* filename,
-        bool* exists,
-        bool verbose = true);
-Vector<const char> ReadFile(FILE* file,
-                            bool* exists,
-                            bool verbose = true);
+V8_EXPORT_PRIVATE std::string ReadFile(const char* filename, bool* exists,
+                                       bool verbose = true);
+std::string ReadFile(FILE* file, bool* exists, bool verbose = true);
 
 template <typename sourcechar, typename sinkchar>
 V8_INLINE static void CopyCharsUnsigned(sinkchar* dest, const sourcechar* src,
@@ -1697,92 +1698,11 @@ bool DoubleToBoolean(double d);
 template <typename Stream>
 bool StringToArrayIndex(Stream* stream, uint32_t* index);
 
-// Returns current value of top of the stack. Works correctly with ASAN.
-DISABLE_ASAN
-inline uintptr_t GetCurrentStackPosition() {
-    // Takes the address of the limit variable in order to find out where
-    // the top of stack is right now.
-    uintptr_t limit = reinterpret_cast<uintptr_t>(&limit);
-    return limit;
-}
-
-template <typename V>
-static inline V ReadUnalignedValue(Address p) {
-    ASSERT_TRIVIALLY_COPYABLE(V);
-#if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
-    return *reinterpret_cast<const V*>(p);
-#else   // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
-    V r;
-    memmove(&r, reinterpret_cast<void*>(p), sizeof(V));
-    return r;
-#endif  // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
-}
-
-template <typename V>
-static inline void WriteUnalignedValue(Address p, V value) {
-    ASSERT_TRIVIALLY_COPYABLE(V);
-#if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
-    *(reinterpret_cast<V*>(p)) = value;
-#else   // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
-    memmove(reinterpret_cast<void*>(p), &value, sizeof(V));
-#endif  // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
-}
-
-static inline double ReadFloatValue(Address p) {
-    return ReadUnalignedValue<float>(p);
-}
-
-static inline double ReadDoubleValue(Address p) {
-    return ReadUnalignedValue<double>(p);
-}
-
-static inline void WriteDoubleValue(Address p, double value) {
-    WriteUnalignedValue(p, value);
-}
-
-static inline uint16_t ReadUnalignedUInt16(Address p) {
-    return ReadUnalignedValue<uint16_t>(p);
-}
-
-static inline void WriteUnalignedUInt16(Address p, uint16_t value) {
-    WriteUnalignedValue(p, value);
-}
-
-static inline uint32_t ReadUnalignedUInt32(Address p) {
-    return ReadUnalignedValue<uint32_t>(p);
-}
-
-static inline void WriteUnalignedUInt32(Address p, uint32_t value) {
-    WriteUnalignedValue(p, value);
-}
-
-template <typename V>
-static inline V ReadLittleEndianValue(Address p) {
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-    return ReadUnalignedValue<V>(p);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-    V ret {};
-    const byte* src = reinterpret_cast<const byte*>(p);
-    byte* dst = reinterpret_cast<byte*>(&ret);
-    for (size_t i = 0; i < sizeof(V); i++) {
-        dst[i] = src[sizeof(V) - i - 1];
-    }
-    return ret;
-#endif  // V8_TARGET_LITTLE_ENDIAN
-}
-
-template <typename V>
-static inline void WriteLittleEndianValue(Address p, V value) {
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-    WriteUnalignedValue<V>(p, value);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-    byte* src = reinterpret_cast<byte*>(&value);
-    byte* dst = reinterpret_cast<byte*>(p);
-    for (size_t i = 0; i < sizeof(V); i++) {
-        dst[i] = src[sizeof(V) - i - 1];
-    }
-#endif  // V8_TARGET_LITTLE_ENDIAN
-}
+// Returns the current stack top. Works correctly with ASAN and SafeStack.
+// GetCurrentStackPosition() should not be inlined, because it works on stack
+// frames if it were inlined into a function with a huge stack frame it would
+// return an address significantly above the actual current stack position.
+V8_NOINLINE uintptr_t GetCurrentStackPosition();
 
 template <typename V>
 static inline V ByteReverse(V value) {
@@ -1827,133 +1747,18 @@ static inline V ByteReverse(V value) {
     }
 }
 
-// Represents a linked list that threads through the nodes in the linked list.
-// Entries in the list are pointers to nodes. The nodes need to have a T**
-// next() method that returns the location where the next value is stored.
-template <typename T>
-class ThreadedList final {
-    public:
-        ThreadedList() : head_(nullptr), tail_(&head_) {}
-        void Add(T* v) {
-            DCHECK_NULL(*tail_);
-            DCHECK_NULL(*v->next());
-            *tail_ = v;
-            tail_ = v->next();
-        }
-
-        void Clear() {
-            head_ = nullptr;
-            tail_ = &head_;
-        }
-
-        class Iterator final {
-            public:
-                Iterator& operator++() {
-                    entry_ = (*entry_)->next();
-                    return *this;
-                }
-                bool operator!=(const Iterator& other) {
-                    return entry_ != other.entry_;
-                }
-                T* operator*() {
-                    return *entry_;
-                }
-                T* operator->() {
-                    return *entry_;
-                }
-                Iterator& operator=(T* entry) {
-                    T* next = *(*entry_)->next();
-                    *entry->next() = next;
-                    *entry_ = entry;
-                    return *this;
-                }
-
-            private:
-                explicit Iterator(T** entry) : entry_(entry) {}
-
-                T** entry_;
-
-                friend class ThreadedList;
-        };
-
-        class ConstIterator final {
-            public:
-                ConstIterator& operator++() {
-                    entry_ = (*entry_)->next();
-                    return *this;
-                }
-                bool operator!=(const ConstIterator& other) {
-                    return entry_ != other.entry_;
-                }
-                const T* operator*() const {
-                    return *entry_;
-                }
-
-            private:
-                explicit ConstIterator(T* const* entry) : entry_(entry) {}
-
-                T* const* entry_;
-
-                friend class ThreadedList;
-        };
-
-        Iterator begin() {
-            return Iterator(&head_);
-        }
-        Iterator end() {
-            return Iterator(tail_);
-        }
-
-        ConstIterator begin() const {
-            return ConstIterator(&head_);
-        }
-        ConstIterator end() const {
-            return ConstIterator(tail_);
-        }
-
-        void Rewind(Iterator reset_point) {
-            tail_ = reset_point.entry_;
-            *tail_ = nullptr;
-        }
-
-        void MoveTail(ThreadedList<T>* parent, Iterator location) {
-            if (parent->end() != location) {
-                DCHECK_NULL(*tail_);
-                *tail_ = *location;
-                tail_ = parent->tail_;
-                parent->Rewind(location);
-            }
-        }
-
-        bool is_empty() const {
-            return head_ == nullptr;
-        }
-
-        // Slow. For testing purposes.
-        int LengthForTest() {
-            int result = 0;
-            for (Iterator t = begin(); t != end(); ++t) {
-                ++result;
-            }
-            return result;
-        }
-        T* AtForTest(int i) {
-            Iterator t = begin();
-            while (i-- > 0) {
-                ++t;
-            }
-            return *t;
-        }
-
-    private:
-        T* head_;
-        T** tail_;
-        DISALLOW_COPY_AND_ASSIGN(ThreadedList);
-};
-
 V8_EXPORT_PRIVATE bool PassesFilter(Vector<const char> name,
                                     Vector<const char> filter);
 
+// Zap the specified area with a specific byte pattern. This currently defaults
+// to int3 on x64 and ia32. On other architectures this will produce unspecified
+// instruction sequences.
+// TODO(jgruber): Better support for other architectures.
+V8_INLINE void ZapCode(Address addr, size_t size_in_bytes) {
+    static constexpr int kZapByte = 0xCC;
+    std::memset(reinterpret_cast<void*>(addr), kZapByte, size_in_bytes);
+}
+
 }  // namespace internal
 }  // namespace v8
 
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/v8memory.h b/test-app/runtime/src/main/cpp/v8_inspector/src/v8memory.h
new file mode 100644
index 000000000..16d779ac9
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/v8memory.h
@@ -0,0 +1,117 @@
+// Copyright 2011 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_V8MEMORY_H_
+#define V8_V8MEMORY_H_
+
+#include "src/globals.h"
+
+namespace v8 {
+namespace internal {
+
+// Memory provides an interface to 'raw' memory. It encapsulates the casts
+// that typically are needed when incompatible pointer types are used.
+// Note that this class currently relies on undefined behaviour. There is a
+// proposal (http://wg21.link/p0593r2) to make it defined behaviour though.
+template <class T>
+T& Memory(Address addr) {
+    return *reinterpret_cast<T*>(addr);
+}
+template <class T>
+T& Memory(byte* addr) {
+    return Memory<T>(reinterpret_cast<Address>(addr));
+}
+
+template <typename V>
+static inline V ReadUnalignedValue(Address p) {
+    ASSERT_TRIVIALLY_COPYABLE(V);
+#if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
+    return *reinterpret_cast<const V*>(p);
+#else   // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
+    V r;
+    memmove(&r, reinterpret_cast<void*>(p), sizeof(V));
+    return r;
+#endif  // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
+}
+
+template <typename V>
+static inline void WriteUnalignedValue(Address p, V value) {
+    ASSERT_TRIVIALLY_COPYABLE(V);
+#if !(V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM)
+    *(reinterpret_cast<V*>(p)) = value;
+#else   // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
+    memmove(reinterpret_cast<void*>(p), &value, sizeof(V));
+#endif  // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_ARM
+}
+
+static inline double ReadFloatValue(Address p) {
+    return ReadUnalignedValue<float>(p);
+}
+
+static inline double ReadDoubleValue(Address p) {
+    return ReadUnalignedValue<double>(p);
+}
+
+static inline void WriteDoubleValue(Address p, double value) {
+    WriteUnalignedValue(p, value);
+}
+
+static inline uint16_t ReadUnalignedUInt16(Address p) {
+    return ReadUnalignedValue<uint16_t>(p);
+}
+
+static inline void WriteUnalignedUInt16(Address p, uint16_t value) {
+    WriteUnalignedValue(p, value);
+}
+
+static inline uint32_t ReadUnalignedUInt32(Address p) {
+    return ReadUnalignedValue<uint32_t>(p);
+}
+
+static inline void WriteUnalignedUInt32(Address p, uint32_t value) {
+    WriteUnalignedValue(p, value);
+}
+
+template <typename V>
+static inline V ReadLittleEndianValue(Address p) {
+#if defined(V8_TARGET_LITTLE_ENDIAN)
+    return ReadUnalignedValue<V>(p);
+#elif defined(V8_TARGET_BIG_ENDIAN)
+    V ret {};
+    const byte* src = reinterpret_cast<const byte*>(p);
+    byte* dst = reinterpret_cast<byte*>(&ret);
+    for (size_t i = 0; i < sizeof(V); i++) {
+        dst[i] = src[sizeof(V) - i - 1];
+    }
+    return ret;
+#endif  // V8_TARGET_LITTLE_ENDIAN
+}
+
+template <typename V>
+static inline void WriteLittleEndianValue(Address p, V value) {
+#if defined(V8_TARGET_LITTLE_ENDIAN)
+    WriteUnalignedValue<V>(p, value);
+#elif defined(V8_TARGET_BIG_ENDIAN)
+    byte* src = reinterpret_cast<byte*>(&value);
+    byte* dst = reinterpret_cast<byte*>(p);
+    for (size_t i = 0; i < sizeof(V); i++) {
+        dst[i] = src[sizeof(V) - i - 1];
+    }
+#endif  // V8_TARGET_LITTLE_ENDIAN
+}
+
+template <typename V>
+static inline V ReadLittleEndianValue(V* p) {
+    return ReadLittleEndianValue<V>(reinterpret_cast<Address>(p));
+}
+
+template <typename V>
+static inline void WriteLittleEndianValue(V* p, V value) {
+    WriteLittleEndianValue<V>(reinterpret_cast<Address>(p), value);
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_V8MEMORY_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/wasm/wasm-feature-flags.h b/test-app/runtime/src/main/cpp/v8_inspector/src/wasm/wasm-feature-flags.h
new file mode 100644
index 000000000..ec8aa8ba0
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/wasm/wasm-feature-flags.h
@@ -0,0 +1,26 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_WASM_WASM_FEATURE_FLAGS_H_
+#define V8_WASM_WASM_FEATURE_FLAGS_H_
+
+// The SEPARATOR argument allows generating proper comma-separated lists.
+#define FOREACH_WASM_FEATURE_FLAG(V, SEPARATOR)                        \
+  V(mv, "multi-value support", false)                                  \
+  SEPARATOR                                                            \
+  V(eh, "exception handling opcodes", false)                           \
+  SEPARATOR                                                            \
+  V(se, "sign extension opcodes", true)                                \
+  SEPARATOR                                                            \
+  V(sat_f2i_conversions, "saturating float conversion opcodes", false) \
+  SEPARATOR                                                            \
+  V(threads, "thread opcodes", false)                                  \
+  SEPARATOR                                                            \
+  V(simd, "SIMD opcodes", false)                                       \
+  SEPARATOR                                                            \
+  V(anyref, "anyref opcodes", false)                                   \
+  SEPARATOR                                                            \
+  V(mut_global, "import/export mutable global support", true)
+
+#endif  // V8_WASM_WASM_FEATURE_FLAGS_H_
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/src/zone/zone.h b/test-app/runtime/src/main/cpp/v8_inspector/src/zone/zone.h
index 3d75f6b5b..d139d4165 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/src/zone/zone.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/src/zone/zone.h
@@ -9,8 +9,10 @@
 
 #include "src/base/hashmap.h"
 #include "src/base/logging.h"
+#include "src/base/threaded-list.h"
 #include "src/globals.h"
 #include "src/splay-tree.h"
+#include "src/utils.h"
 #include "src/zone/accounting-allocator.h"
 
 #ifndef ZONE_NAME
@@ -58,6 +60,10 @@ class V8_EXPORT_PRIVATE Zone final {
             sealed_ = true;
         }
 
+        // Allows the zone to be safely reused. Releases the memory and fires zone
+        // destruction and creation events for the accounting allocator.
+        void ReleaseMemory();
+
         // Returns true if more memory has been allocated in zones than
         // the limit allows.
         bool excess_allocation() const {
@@ -77,6 +83,9 @@ class V8_EXPORT_PRIVATE Zone final {
         }
 
     private:
+        // Deletes all objects and free all memory allocated in the Zone.
+        void DeleteAll();
+
         // All pointers returned from New() are 8-byte aligned.
         static const size_t kAlignmentInBytes = 8;
 
@@ -89,9 +98,6 @@ class V8_EXPORT_PRIVATE Zone final {
         // Report zone excess when allocation exceeds this limit.
         static const size_t kExcessLimit = 256 * MB;
 
-        // Deletes all objects and free all memory allocated in the Zone.
-        void DeleteAll();
-
         // The number of bytes allocated in this zone so far.
         size_t allocation_size_;
 
@@ -347,6 +353,11 @@ class ZoneList final {
 template <typename T>
 using ZonePtrList = ZoneList<T*>;
 
+// ZoneThreadedList is a special variant of the ThreadedList that can be put
+// into a Zone.
+template <typename T, typename TLTraits = base::ThreadedListTraits<T>>
+using ZoneThreadedList = base::ThreadedListBase<T, ZoneObject, TLTraits>;
+
 // A zone splay tree.  The config type parameter encapsulates the
 // different configurations of a concrete splay tree (see splay-tree.h).
 // The tree itself and all its elements are allocated in the Zone.
diff --git a/test-app/runtime/src/main/cpp/v8_inspector/third_party/googletest/src/googletest/include/gtest/gtest_prod.h b/test-app/runtime/src/main/cpp/v8_inspector/third_party/googletest/src/googletest/include/gtest/gtest_prod.h
index 89314f405..e651671eb 100644
--- a/test-app/runtime/src/main/cpp/v8_inspector/third_party/googletest/src/googletest/include/gtest/gtest_prod.h
+++ b/test-app/runtime/src/main/cpp/v8_inspector/third_party/googletest/src/googletest/include/gtest/gtest_prod.h
@@ -26,10 +26,10 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
+
 //
 // Google C++ Testing and Mocking Framework definitions useful in production code.
+// GOOGLETEST_CM0003 DO NOT DELETE
 
 #ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
 #define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java
index 1c10e3f97..dd3881f06 100644
--- a/test-app/runtime/src/main/java/com/tns/Runtime.java
+++ b/test-app/runtime/src/main/java/com/tns/Runtime.java
@@ -48,10 +48,12 @@ private native void initNativeScript(int runtimeId, String filesPath, String nat
     private native int generateNewObjectId(int runtimeId);
 
     private native boolean notifyGc(int runtimeId);
+
     private native void lock(int runtimeId);
+
     private native void unlock(int runtimeId);
 
-    private native void passUncaughtExceptionToJsNative(int runtimeId, Throwable ex, String stackTrace);
+    private native void passExceptionToJsNative(int runtimeId, Throwable ex, String stackTrace, boolean isDiscarded);
 
     private native void clearStartupData(int runtimeId);
 
@@ -72,7 +74,20 @@ private native void initNativeScript(int runtimeId, String filesPath, String nat
     private static native void ResetDateTimeConfigurationCache(int runtimeId);
 
     void passUncaughtExceptionToJs(Throwable ex, String stackTrace) {
-        passUncaughtExceptionToJsNative(getRuntimeId(), ex, stackTrace);
+        passExceptionToJsNative(getRuntimeId(), ex, stackTrace, false);
+    }
+
+    void passDiscardedExceptionToJs(Throwable ex, String message) {
+        String stackTrace = message + Runtime.getStackTraceErrorMessage(ex);
+        passExceptionToJsNative(getRuntimeId(), ex, stackTrace, true);
+    }
+
+    public static void passSuppressedExceptionToJs(Throwable ex, String methodName) {
+        com.tns.Runtime runtime = com.tns.Runtime.getCurrentRuntime();
+        if (runtime != null) {
+            String errorMessage = "Error on \"" + Thread.currentThread().getName() + "\" thread for " + methodName + "\n";
+            runtime.passDiscardedExceptionToJs(ex, errorMessage);
+        }
     }
 
     private boolean initialized;
@@ -85,13 +100,13 @@ void passUncaughtExceptionToJs(Throwable ex, String stackTrace) {
             "Primitive types need to be manually wrapped in their respective Object wrappers.\n" +
             "If you are creating an instance of an inner class, make sure to always provide reference to the outer `this` as the first argument.";
 
-    private final HashMap<Integer, Object> strongInstances = new HashMap<>();
+    private HashMap<Integer, Object> strongInstances = new HashMap<>();
 
-    private final HashMap<Integer, WeakReference<Object>> weakInstances = new HashMap<>();
+    private HashMap<Integer, WeakReference<Object>> weakInstances = new HashMap<>();
 
-    private final NativeScriptHashMap<Object, Integer> strongJavaObjectToID = new NativeScriptHashMap<Object, Integer>();
+    private NativeScriptHashMap<Object, Integer> strongJavaObjectToID = new NativeScriptHashMap<Object, Integer>();
 
-    private final NativeScriptWeakHashMap<Object, Integer> weakJavaObjectToID = new NativeScriptWeakHashMap<Object, Integer>();
+    private NativeScriptWeakHashMap<Object, Integer> weakJavaObjectToID = new NativeScriptWeakHashMap<Object, Integer>();
 
     private final Map<Class<?>, JavaScriptImplementation> loadedJavaScriptExtends = new HashMap<Class<?>, JavaScriptImplementation>();
 
@@ -107,8 +122,14 @@ void passUncaughtExceptionToJs(Throwable ex, String stackTrace) {
     private Logger logger;
 
     private boolean isLiveSyncStarted;
-    public boolean getIsLiveSyncStarted() { return this.isLiveSyncStarted; }
-    public void setIsLiveSyncStarted(boolean value) { this.isLiveSyncStarted = value; }
+
+    public boolean getIsLiveSyncStarted() {
+        return this.isLiveSyncStarted;
+    }
+
+    public void setIsLiveSyncStarted(boolean value) {
+        this.isLiveSyncStarted = value;
+    }
 
     public Logger getLogger() {
         return this.logger;
@@ -158,6 +179,19 @@ public int compare(Method lhs, Method rhs) {
      */
     private Map<Integer, Handler> workerIdToHandler = new HashMap<>();
 
+    public Runtime(ClassResolver classResolver, GcListener gcListener, StaticConfiguration config, DynamicConfiguration dynamicConfig, int runtimeId, int workerId, HashMap<Integer, Object> strongInstances, HashMap<Integer, WeakReference<Object>> weakInstances, NativeScriptHashMap<Object, Integer> strongJavaObjectToId, NativeScriptWeakHashMap<Object, Integer> weakJavaObjectToId) {
+        this.classResolver = classResolver;
+        this.gcListener = gcListener;
+        this.config = config;
+        this.dynamicConfig = dynamicConfig;
+        this.runtimeId = runtimeId;
+        this.workerId = workerId;
+        this.strongInstances = strongInstances;
+        this.weakInstances = weakInstances;
+        this.strongJavaObjectToID = strongJavaObjectToId;
+        this.weakJavaObjectToID = weakJavaObjectToId;
+    }
+
     public Runtime(StaticConfiguration config, DynamicConfiguration dynamicConfiguration) {
         synchronized (Runtime.currentRuntime) {
             ManualInstrumentation.Frame frame = ManualInstrumentation.start("new Runtime");
@@ -211,6 +245,29 @@ private static Runtime getObjectRuntime(Object object) {
         return runtime;
     }
 
+    public static String getStackTraceErrorMessage(Throwable ex) {
+        String content;
+        java.io.PrintStream ps = null;
+
+        try {
+            java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
+            ps = new java.io.PrintStream(baos);
+            ex.printStackTrace(ps);
+
+            try {
+                content = baos.toString("US-ASCII");
+            } catch (java.io.UnsupportedEncodingException e) {
+                content = e.getMessage();
+            }
+        } finally {
+            if (ps != null) {
+                ps.close();
+            }
+        }
+
+        return content;
+    }
+
     public DynamicConfiguration getDynamicConfig() {
         return dynamicConfig;
     }
@@ -220,7 +277,7 @@ public int getMarkingModeOrdinal() {
         if (staticConfiguration != null && staticConfiguration.appConfig != null) {
             return staticConfiguration.appConfig.getMarkingMode().ordinal();
         } else {
-            return ((MarkingMode)AppConfig.KnownKeys.MarkingMode.getDefaultValue()).ordinal();
+            return ((MarkingMode) AppConfig.KnownKeys.MarkingMode.getDefaultValue()).ordinal();
         }
     }
 
@@ -244,6 +301,20 @@ public void ResetDateTimeConfigurationCache() {
         }
     }
 
+    public void releaseNativeCounterpart(int nativeObjectId) {
+        Object strongRef = strongInstances.get(nativeObjectId);
+        if (strongRef != null) {
+            strongInstances.remove(nativeObjectId);
+            strongJavaObjectToID.remove(strongRef);
+        }
+
+        WeakReference<Object> weakRef = weakInstances.get(nativeObjectId);
+        if (weakRef != null) {
+            weakInstances.remove(nativeObjectId);
+            weakJavaObjectToID.remove(weakRef);
+        }
+    }
+
     private static class WorkerThreadHandler extends Handler {
         @Override
         public void handleMessage(Message msg) {
@@ -554,6 +625,10 @@ public void runModule(File jsFile) throws NativeScriptException {
     }
 
     public Object runScript(File jsFile) throws NativeScriptException {
+        return this.runScript(jsFile, true);
+    }
+
+    public Object runScript(File jsFile, final boolean waitForResultOnMainThread) throws NativeScriptException {
         Object result = null;
 
         if (jsFile.exists() && jsFile.isFile()) {
@@ -585,7 +660,7 @@ public void run() {
                 if (success) {
                     synchronized (r) {
                         try {
-                            if (arr[1] == null) {
+                            if (arr[1] == null && waitForResultOnMainThread) {
                                 r.wait();
                             }
                         } catch (InterruptedException e) {
@@ -612,9 +687,17 @@ private long getUsedMemory() {
         return usedMemory;
     }
 
-    public void notifyGc() { notifyGc(runtimeId); }
-    public void lock() { lock(runtimeId); }
-    public void unlock() { unlock(runtimeId); }
+    public void notifyGc() {
+        notifyGc(runtimeId);
+    }
+
+    public void lock() {
+        lock(runtimeId);
+    }
+
+    public void unlock() {
+        unlock(runtimeId);
+    }
 
     public static void initInstance(Object instance) {
         ManualInstrumentation.Frame frame = ManualInstrumentation.start("Runtime.initInstance");
@@ -855,7 +938,7 @@ private boolean makeInstanceWeakAndCheckIfAlive(int javaObjectID) {
                 if (instance == null) {
                     // The Java was moved from strong to weak, and then the Java instance was collected.
                     weakInstances.remove(javaObjectID);
-                    weakJavaObjectToID.remove(javaObjectID);
+                    weakJavaObjectToID.remove(ref);
                     return false;
                 } else {
                     return true;
@@ -1088,7 +1171,7 @@ private Object[] extendConstructorArgs(String methodName, boolean isConstructor,
         if (methodName.equals("init")) {
             if (args == null) {
                 arr = new Object[]
-                {isConstructor};
+                        {isConstructor};
             } else {
                 arr = new Object[args.length + 1];
                 System.arraycopy(args, 0, arr, 0, args.length);
@@ -1119,9 +1202,10 @@ private Object dispatchCallJSMethodNative(final int javaObjectID, final String m
             try {
                 ret = callJSMethodNative(getRuntimeId(), javaObjectID, methodName, returnType, isConstructor, packagedArgs);
             } catch (NativeScriptException e) {
-                if(discardUncaughtJsExceptions) {
-                    logger.write("Error on currentThread for callJSMethodNative:", e.getMessage());
-                    e.printStackTrace();
+                if (discardUncaughtJsExceptions) {
+                    String errorMessage = "Error on \"" + Thread.currentThread().getName() + "\" thread for callJSMethodNative\n";
+                    android.util.Log.w("Warning", "NativeScript discarding uncaught JS exception!");
+                    passDiscardedExceptionToJs(e, errorMessage);
                 } else {
                     throw e;
                 }
@@ -1139,9 +1223,10 @@ public void run() {
                             final Object[] packagedArgs = packageArgs(tmpArgs);
                             arr[0] = callJSMethodNative(getRuntimeId(), javaObjectID, methodName, returnType, isCtor, packagedArgs);
                         } catch (NativeScriptException e) {
-                            if(discardUncaughtJsExceptions) {
-                                logger.write("Error off currentThread for callJSMethodNative:", e.getMessage());
-                                e.printStackTrace();
+                            if (discardUncaughtJsExceptions) {
+                                String errorMessage = "Error on \"" + Thread.currentThread().getName() + "\" thread for callJSMethodNative\n";
+                                passDiscardedExceptionToJs(e, errorMessage);
+                                android.util.Log.w("Warning", "NativeScript discarding uncaught JS exception!");
                             } else {
                                 throw e;
                             }
diff --git a/test-app/runtime/src/main/java/fi/iki/elonen/NanoWSD.java b/test-app/runtime/src/main/java/fi/iki/elonen/NanoWSD.java
index ea57b1bf5..59404e72a 100644
--- a/test-app/runtime/src/main/java/fi/iki/elonen/NanoWSD.java
+++ b/test-app/runtime/src/main/java/fi/iki/elonen/NanoWSD.java
@@ -101,6 +101,8 @@ public boolean isOpen() {
             return state == State.OPEN;
         }
 
+        public State getState() { return this.state; }
+
         protected abstract void onOpen();
 
         protected abstract void onClose(CloseCode code, String reason, boolean initiatedByRemote);
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_base.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_base.a
index d0203bc30..fca37c283 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_base.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_base.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_init.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_init.a
index d13f81ff4..1365b2935 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_init.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_init.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_initializers.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_initializers.a
index b58b15d45..b54f83150 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_initializers.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_initializers.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libbase.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libbase.a
index 191d547e1..a9d76d197 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libbase.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libbase.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libplatform.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libplatform.a
index b4de7b47d..0b8712caa 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libplatform.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libplatform.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libsampler.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libsampler.a
index f4b3caaf7..070144a47 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_libsampler.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_libsampler.a differ
diff --git a/test-app/runtime/src/main/libs/arm64-v8a/libv8_snapshot.a b/test-app/runtime/src/main/libs/arm64-v8a/libv8_snapshot.a
index ecc5d93f5..e73cace98 100644
Binary files a/test-app/runtime/src/main/libs/arm64-v8a/libv8_snapshot.a and b/test-app/runtime/src/main/libs/arm64-v8a/libv8_snapshot.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_base.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_base.a
index 2afcc3f11..409970fe1 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_base.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_base.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_init.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_init.a
index c4e5eb713..e970112d0 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_init.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_init.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_initializers.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_initializers.a
index 026efb88e..d0f458d25 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_initializers.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_initializers.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libbase.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libbase.a
index 13955a4c8..fec455c32 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libbase.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libbase.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libplatform.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libplatform.a
index e5a31f296..cde2ab2de 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libplatform.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libplatform.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libsampler.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libsampler.a
index 2bfa69aeb..8da73ba29 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libsampler.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_libsampler.a differ
diff --git a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_snapshot.a b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_snapshot.a
index 9ec45fc2b..cd6d4b48c 100644
Binary files a/test-app/runtime/src/main/libs/armeabi-v7a/libv8_snapshot.a and b/test-app/runtime/src/main/libs/armeabi-v7a/libv8_snapshot.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_base.a b/test-app/runtime/src/main/libs/x86/libv8_base.a
index b55ad2911..043cc600d 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_base.a and b/test-app/runtime/src/main/libs/x86/libv8_base.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_init.a b/test-app/runtime/src/main/libs/x86/libv8_init.a
index 800c388f8..1d063b8da 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_init.a and b/test-app/runtime/src/main/libs/x86/libv8_init.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_initializers.a b/test-app/runtime/src/main/libs/x86/libv8_initializers.a
index dd3d3d05d..ab861e9d4 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_initializers.a and b/test-app/runtime/src/main/libs/x86/libv8_initializers.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_libbase.a b/test-app/runtime/src/main/libs/x86/libv8_libbase.a
index 4b7699aa0..0d5ff9fbc 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_libbase.a and b/test-app/runtime/src/main/libs/x86/libv8_libbase.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_libplatform.a b/test-app/runtime/src/main/libs/x86/libv8_libplatform.a
index 1b1d668ea..d08697c1a 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_libplatform.a and b/test-app/runtime/src/main/libs/x86/libv8_libplatform.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_libsampler.a b/test-app/runtime/src/main/libs/x86/libv8_libsampler.a
index 0ed155097..21431cbba 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_libsampler.a and b/test-app/runtime/src/main/libs/x86/libv8_libsampler.a differ
diff --git a/test-app/runtime/src/main/libs/x86/libv8_snapshot.a b/test-app/runtime/src/main/libs/x86/libv8_snapshot.a
index 420533729..3da7ee7ec 100644
Binary files a/test-app/runtime/src/main/libs/x86/libv8_snapshot.a and b/test-app/runtime/src/main/libs/x86/libv8_snapshot.a differ
diff --git a/test-app/runtime/src/test/java/com/tns/RuntimeTest.java b/test-app/runtime/src/test/java/com/tns/RuntimeTest.java
new file mode 100644
index 000000000..265062ced
--- /dev/null
+++ b/test-app/runtime/src/test/java/com/tns/RuntimeTest.java
@@ -0,0 +1,90 @@
+package com.tns;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RuntimeTest {
+
+    private static final int TESTING_NATIVE_OBJECT_ID = 666;
+    private static final Object TESTING_NATIVE_OBJECT = new Object();
+
+    private Runtime runtime;
+
+    @Mock
+    private HashMap<Integer, Object> strongInstances;
+
+    @Mock
+    private HashMap<Integer, WeakReference<Object>> weakInstances;
+
+    @Mock
+    private NativeScriptHashMap<Object, Integer> strongJavaObjectToId;
+
+    @Mock
+    private NativeScriptWeakHashMap<Object, Integer> weakJavaObjectToId;
+
+    @Mock
+    private WeakReference<Object> testingObjectWeakRefMock;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        runtime = new Runtime(mock(ClassResolver.class),
+                mock(GcListener.class),
+                mock(StaticConfiguration.class),
+                mock(DynamicConfiguration.class),
+                0,
+                0,
+                strongInstances,
+                weakInstances,
+                strongJavaObjectToId,
+                weakJavaObjectToId);
+    }
+
+    @Test
+    public void testStrongInstanceIsSuccessfullyRemoved() {
+        when(strongInstances.get(TESTING_NATIVE_OBJECT_ID)).thenReturn(TESTING_NATIVE_OBJECT);
+
+        runtime.releaseNativeCounterpart(TESTING_NATIVE_OBJECT_ID);
+
+        verify(strongInstances).remove(TESTING_NATIVE_OBJECT_ID);
+        verify(strongJavaObjectToId).remove(TESTING_NATIVE_OBJECT);
+    }
+
+    @Test
+    public void testWeakInstanceIsSuccessfullyRemoved(){
+        when(weakInstances.get(TESTING_NATIVE_OBJECT_ID)).thenReturn(testingObjectWeakRefMock);
+
+        runtime.releaseNativeCounterpart(TESTING_NATIVE_OBJECT_ID);
+
+        verify(weakInstances).remove(TESTING_NATIVE_OBJECT_ID);
+        verify(weakJavaObjectToId).remove(testingObjectWeakRefMock);
+    }
+
+    @Test
+    public void testStrongAndWeakInstancesAreSuccessfullyRemoved(){
+        when(strongInstances.get(TESTING_NATIVE_OBJECT_ID)).thenReturn(TESTING_NATIVE_OBJECT);
+        when(weakInstances.get(TESTING_NATIVE_OBJECT_ID)).thenReturn(testingObjectWeakRefMock);
+
+        runtime.releaseNativeCounterpart(TESTING_NATIVE_OBJECT_ID);
+
+        verify(strongInstances).remove(TESTING_NATIVE_OBJECT_ID);
+        verify(strongJavaObjectToId).remove(TESTING_NATIVE_OBJECT);
+        verify(weakInstances).remove(TESTING_NATIVE_OBJECT_ID);
+        verify(weakJavaObjectToId).remove(testingObjectWeakRefMock);
+    }
+}
diff --git a/v8-versions.json b/v8-versions.json
index 4fceb5a62..bbe1acecf 100644
--- a/v8-versions.json
+++ b/v8-versions.json
@@ -1,4 +1,5 @@
 {
+    ">=5.1.9 <5.3.0": "7.1.302.32",
     ">=4.2.9 <5.2.0": "6.9.427.23",
     ">=4.1.9 <4.3.0": "6.7.288.46",
     ">=4.0.9 <4.1.9": "6.6.346.23",