diff --git a/build.gradle b/build.gradle index 299f0a95..d7a9eebc 100644 --- a/build.gradle +++ b/build.gradle @@ -5,6 +5,7 @@ buildscript { apply from: rootProject.file("dependencies.gradle") repositories { + mavenLocal() google() mavenCentral() gradlePluginPortal() diff --git a/deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/base/ManifestGeneration.kt b/deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/base/ManifestGeneration.kt index 34ac6648..0854b6b7 100644 --- a/deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/base/ManifestGeneration.kt +++ b/deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/base/ManifestGeneration.kt @@ -1,13 +1,24 @@ package com.airbnb.deeplinkdispatch.base /** - * Constants related to manifest generation for DeepLinkDispatch. + * Constants related to manifest and asset generation for DeepLinkDispatch. * * These constants are shared between: - * - The KSP processor that generates the manifest - * - The Gradle plugin that reads and merges the generated manifest + * - The KSP processor that generates the manifest and match index assets + * - The Gradle plugin that reads and merges the generated manifest and assets */ object ManifestGeneration { + /** + * KSP argument key to enable asset-based match index generation. + * + * When this argument is set to "true", the KSP processor will: + * - Write the binary match index as an asset file instead of encoding it as a string + * - Generate a registry class that loads the index from assets via AssetManager + * + * This is automatically set by ManifestGenerationPlugin when applied to library modules. + */ + const val OPTION_USE_ASSET_BASED_MATCH_INDEX = "deepLink.useAssetBasedMatchIndex" + /** * The resource path where the KSP processor writes the generated AndroidManifest.xml. * @@ -18,4 +29,63 @@ object ManifestGeneration { * - ManifestGenerationPlugin to locate and merge the generated manifest */ const val MANIFEST_RESOURCE_PATH = "deeplinkdispatch/AndroidManifest.xml" + + /** + * The asset directory prefix where the KSP processor writes the binary match index files. + * + * The full path will be: build/generated/ksp//resources/assets//.bin + * + * This path is used by: + * - DeepLinkProcessor in the processor to write the match index via XFiler.writeResource() + * - ManifestGenerationPlugin to locate and merge the generated assets + * - Generated registry classes at runtime to load the match index via AssetManager + */ + const val MATCH_INDEX_ASSET_PATH_PREFIX = "deeplinkdispatch" + + /** + * File extension for match index asset files. + */ + const val MATCH_INDEX_ASSET_EXTENSION = ".bin" + + /** + * Generates the asset path for a given module name's match index. + * + * @param moduleName The module name (will be lowercased) + * @return The asset path relative to the assets directory + */ + fun getMatchIndexAssetPath(moduleName: String): String = + "$MATCH_INDEX_ASSET_PATH_PREFIX/${moduleName.lowercase()}$MATCH_INDEX_ASSET_EXTENSION" + + /** + * Generates the full resource path (including assets/ prefix) for writing the match index via XFiler. + * + * @param moduleName The module name (will be lowercased) + * @return The resource path for XFiler.writeResource() + */ + fun getMatchIndexResourcePath(moduleName: String): String = "assets/${getMatchIndexAssetPath(moduleName)}" + + /** + * Subdirectory inside the KSP output where `XFiler.writeResource()` places files. + * Full path: `build/generated/ksp//resources/...` + */ + const val KSP_RESOURCES_SUBDIR = "resources" + + /** + * Returns the build-relative path to KSP's generated resources directory for a variant. + * Example: `generated/ksp/debug/resources` + */ + fun kspResourcesDir(variantName: String): String = "generated/ksp/$variantName/$KSP_RESOURCES_SUBDIR" + + /** + * Returns the build-relative path to the generated manifest under KSP resources for a variant. + */ + fun kspGeneratedManifestPath(variantName: String): String = + "${kspResourcesDir(variantName)}/$MANIFEST_RESOURCE_PATH" + + /** + * Returns the build-relative path to the directory containing the generated asset files under + * KSP resources for a variant. + */ + fun kspGeneratedAssetsDir(variantName: String): String = + "${kspResourcesDir(variantName)}/assets/$MATCH_INDEX_ASSET_PATH_PREFIX" } diff --git a/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/ManifestGenerationPlugin.kt b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/ManifestGenerationPlugin.kt index 2b8379da..b6f7158a 100644 --- a/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/ManifestGenerationPlugin.kt +++ b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/ManifestGenerationPlugin.kt @@ -5,34 +5,44 @@ import com.android.build.api.artifact.SingleArtifact import com.android.build.api.variant.AndroidComponentsExtension import com.android.build.api.variant.HasHostTests import com.android.manifmerger.ManifestMerger2 +import com.google.devtools.ksp.gradle.KspExtension import org.gradle.api.Plugin import org.gradle.api.Project /** - * Automatic manifest generation plugin for DeepLinkDispatch. + * Automatic manifest and asset generation plugin for DeepLinkDispatch. * - * For deep links that have activityClassFqn set, the DeepLinkDispatch annotation processor generates - * an AndroidManifest.xml that contains the intent filters for the deeplinks. + * This plugin handles two main features for KSP-based builds: * - * This plugin uses AGP's Artifacts API to transform the MERGED_MANIFEST artifact, - * merging in the KSP-generated manifest with intent filters. + * ## 1. Manifest Generation + * For deep links that have activityClassFqn set, the DeepLinkDispatch annotation processor generates + * an AndroidManifest.xml that contains the intent filters for the deeplinks. This plugin uses AGP's + * Artifacts API to transform the MERGED_MANIFEST artifact, merging in the KSP-generated manifest. * - * This means that for any deep links that have activityClassFqn set it is not necessary to add the - * intent filters to the AndroidManifest.xml manually. + * ## 2. Asset-Based Match Index (KSP only) + * When using KSP, the processor generates a binary match index file as an Android asset instead of + * encoding it as strings in the generated registry class. This provides: + * - Faster build times (no string chunking/encoding) + * - Faster app startup (direct binary loading, no string decoding) + * - Smaller APK size (binary assets compress better than dex strings) * * IMPORTANT: This plugin requires AGP 8.0+ and only works with KSP (Kotlin Symbol Processing). - * It does NOT work with KAPT. If you're using KAPT, you must manually add intent filters - * to your AndroidManifest.xml. + * It does NOT work with KAPT. If you're using KAPT: + * - You must manually add intent filters to your AndroidManifest.xml + * - The match index will use the legacy string-based approach (still works, just less efficient) * * How it works (AGP 8.0+): - * 1. KSP processes annotations and generates a manifest file with intent filters - * 2. This plugin uses variant.artifacts.use().toTransform(SingleArtifact.MERGED_MANIFEST) - * to intercept the merged manifest and add the KSP-generated intent filters - * 3. The transformed manifest is used by all subsequent tasks in the build pipeline - * 4. The final merged manifest with intent filters is packaged into the APK/AAR + * 1. KSP processes annotations and generates: + * - A manifest file with intent filters (if activityClassFqn is set) + * - A binary match index asset file (assets/deeplinkdispatch/.bin) + * 2. This plugin uses variant.artifacts.use().toTransform() to intercept: + * - SingleArtifact.MERGED_MANIFEST - adds the KSP-generated intent filters + * - SingleArtifact.ASSETS - adds the binary match index files + * 3. The transformed artifacts are used by all subsequent tasks in the build pipeline + * 4. The final APK/AAR includes both the merged manifest and the binary match index * - * This ensures that generated manifest entries are included on the first build without requiring - * two build passes or manual manifest modifications. + * This ensures that generated content is included on the first build without requiring + * two build passes or manual modifications. */ class ManifestGenerationPlugin: Plugin { @@ -56,38 +66,42 @@ class ManifestGenerationPlugin: Plugin { ) } + // Configure KSP to use asset-based match index when this plugin is applied. + // Using pluginManager.withPlugin ensures we apply the arg whenever KSP is present, + // regardless of whether it is applied before or after this plugin. + project.pluginManager.withPlugin("com.google.devtools.ksp") { + val ksp = project.extensions.getByType(KspExtension::class.java) + ksp.arg(ManifestGeneration.OPTION_USE_ASSET_BASED_MATCH_INDEX, "true") + } + val androidComponents = project.extensions.getByType( AndroidComponentsExtension::class.java ) androidComponents.onVariants { variant -> - // Merge type is always library as this does not support application modules val mergeType = ManifestMerger2.MergeType.LIBRARY + val variantName = variant.name + val variantCapitalized = variantName.replaceFirstChar { it.uppercase() } + val kspTaskName = "ksp${variantCapitalized}Kotlin" - // Path where KSP writes the manifest via filer API (this is cached by Gradle) - val kspGeneratedManifestPath = "generated/ksp/${variant.name}/resources/${ManifestGeneration.MANIFEST_RESOURCE_PATH}" - // Safe location where we move the manifest to prevent it from being picked up by Java resource merge - val safeManifestPath = "intermediates/deeplinkdispatch/${variant.name}/AndroidManifest.xml" + // Build-dir-relative paths (all centralized in ManifestGeneration) + val kspGeneratedManifestPath = ManifestGeneration.kspGeneratedManifestPath(variantName) + val kspGeneratedAssetsPath = ManifestGeneration.kspGeneratedAssetsDir(variantName) + val kspKotlinOutputPath = "generated/ksp/$variantName/kotlin" + val safeManifestPath = "intermediates/deeplinkdispatch/$variantName/AndroidManifest.xml" + val safeAssetsPath = "intermediates/deeplinkdispatch/$variantName/assets" val manifestMergeTask = project.tasks.register( GenerateManifestIntentFiltersForDeeplinkDispatchTask.taskName(variant), GenerateManifestIntentFiltersForDeeplinkDispatchTask::class.java ) { - // Read manifest from safe location (moved there by KSP doLast action) generatedManifestPath.set(project.layout.buildDirectory.file(safeManifestPath)) - // Set KSP output directory as an input to establish dependency on KSP task - kspOutputDirectory.set(project.layout.buildDirectory.dir( - "generated/ksp/${variant.name}/kotlin" - )) - // Set merge type determined during configuration phase + kspOutputDirectory.set(project.layout.buildDirectory.dir(kspKotlinOutputPath)) this.mergeType.set(mergeType) group = "deeplinkdispatch" - description = "Merges KSP-generated manifest for ${variant.name}" + description = "Merges KSP-generated manifest for $variantName" } - // Transform MERGED_MANIFEST - // By making our task depend on KSP output directory, we establish that KSP must run first - // This might create a circular dependency in app modules but could work for libraries variant.artifacts.use(manifestMergeTask) .wiredWithFiles( GenerateManifestIntentFiltersForDeeplinkDispatchTask::mergedManifest, @@ -95,67 +109,87 @@ class ManifestGenerationPlugin: Plugin { ) .toTransform(SingleArtifact.MERGED_MANIFEST) - // Register a task to move the manifest from KSP resources to a safe location. - // This must be a separate task (not doLast on KSP) because doLast doesn't run - // when KSP is restored FROM-CACHE. + // Moves the manifest out of the KSP resources dir so it isn't picked up as a Java + // resource. Must be a separate task (rather than a KSP `doLast`) because `doLast` + // doesn't run when KSP is restored FROM-CACHE. val relocateManifestTask = project.tasks.register( - "relocateDeepLinkManifest${variant.name.replaceFirstChar { it.uppercase() }}", + "relocateDeepLinkManifest$variantCapitalized", RelocateDeepLinkManifestTask::class.java ) { kspManifestFile.set(project.layout.buildDirectory.file(kspGeneratedManifestPath)) safeManifestFile.set(project.layout.buildDirectory.file(safeManifestPath)) group = "deeplinkdispatch" - description = "Moves DeepLinkDispatch manifest from KSP resources to safe location for ${variant.name}" + description = "Moves DeepLinkDispatch manifest from KSP resources to safe location for $variantName" } - // Configure task ordering AFTER evaluation when KSP task exists - project.afterEvaluate { - val kspTaskName = "ksp${variant.name.replaceFirstChar { it.uppercase() }}Kotlin" - val kspTask = project.tasks.findByName(kspTaskName) + val relocateAssetsTask = project.tasks.register( + "relocateDeepLinkAssets$variantCapitalized", + RelocateDeepLinkAssetsTask::class.java + ) { + kspAssetsDir.set(project.layout.buildDirectory.dir(kspGeneratedAssetsPath)) + safeAssetsDir.set(project.layout.buildDirectory.dir(safeAssetsPath)) + group = "deeplinkdispatch" + description = "Moves DeepLinkDispatch assets from KSP resources to safe location for $variantName" + } - if (kspTask != null) { - // Relocate task runs after KSP - relocateManifestTask.configure { - dependsOn(kspTask) - } - } + val mergeAssetsTask = project.tasks.register( + MergeDeepLinkAssetsTask.taskName(variant), + MergeDeepLinkAssetsTask::class.java + ) { + additionalAssetsDir.set(project.layout.buildDirectory.dir(safeAssetsPath)) + group = "deeplinkdispatch" + description = "Merges DeepLinkDispatch assets for $variantName" + } - // Manifest merge task always runs after relocate (regardless of KSP presence) - manifestMergeTask.configure { - dependsOn(relocateManifestTask) + variant.artifacts.use(mergeAssetsTask) + .wiredWithDirectories( + MergeDeepLinkAssetsTask::inputAssets, + MergeDeepLinkAssetsTask::outputAssets + ) + .toTransform(SingleArtifact.ASSETS) + + // Merge tasks always run after their respective relocate task; these are in-plugin + // task providers so they can be wired lazily without `findByName`. + manifestMergeTask.configure { dependsOn(relocateManifestTask) } + mergeAssetsTask.configure { dependsOn(relocateAssetsTask) } + + // Wire KSP -> relocate only when the KSP plugin is applied. We use `tasks.matching` + // (not `named`) because KSP registers its variant-specific tasks lazily during + // project evaluation, possibly after this block runs. + project.pluginManager.withPlugin("com.google.devtools.ksp") { + project.tasks.matching { it.name == kspTaskName }.configureEach { + // no-op; ensures the task is realized } - - // Wire relocate task into the library's Java resource processing pipeline. - // This ensures the manifest file is moved before the library's resources are processed, - // so when an app depends on this library, the file won't be in the resources. - // processJavaRes is critical - it's the task that collects resources from source - // directories and is what consuming app modules depend on. - val variantCapitalized = variant.name.replaceFirstChar { it.uppercase() } - listOf( - "process${variantCapitalized}JavaRes", - "merge${variantCapitalized}JavaResource", - "bundleLibCompileToJar${variantCapitalized}", - "bundleLibRuntimeToJar${variantCapitalized}", - "sync${variantCapitalized}LibJars" - ).forEach { taskName -> - project.tasks.findByName(taskName)?.let { task -> - task.dependsOn(relocateManifestTask) - } + relocateManifestTask.configure { + dependsOn(project.tasks.matching { it.name == kspTaskName }) + } + relocateAssetsTask.configure { + dependsOn(project.tasks.matching { it.name == kspTaskName }) } } - // Also transform the manifest for host tests (unit tests) so that - // Robolectric tests can access the merged intent filters via PackageManager + // Make the library's Java-resource and jar-bundling tasks run after our relocate + // tasks so the KSP-generated files aren't copied into the AAR as Java resources. + val javaResourceTaskNames = setOf( + "process${variantCapitalized}JavaRes", + "merge${variantCapitalized}JavaResource", + "bundleLibCompileToJar$variantCapitalized", + "bundleLibRuntimeToJar$variantCapitalized", + "sync${variantCapitalized}LibJars", + ) + project.tasks.matching { it.name in javaResourceTaskNames }.configureEach { + dependsOn(relocateManifestTask, relocateAssetsTask) + } + + // Also transform the manifest for host tests (unit tests) so that Robolectric tests + // can access the merged intent filters via PackageManager. (variant as? HasHostTests)?.hostTests?.forEach { (_, hostTest) -> val hostTestManifestMergeTask = project.tasks.register( "${hostTest.name}GenerateManifestIntentFiltersForDeepLinkDispatch", GenerateManifestIntentFiltersForDeeplinkDispatchTask::class.java ) { - // Read manifest from safe location (moved there by KSP doLast action) generatedManifestPath.set(project.layout.buildDirectory.file(safeManifestPath)) - kspOutputDirectory.set(project.layout.buildDirectory.dir( - "generated/ksp/${variant.name}/kotlin" - )) + kspOutputDirectory.set(project.layout.buildDirectory.dir(kspKotlinOutputPath)) this.mergeType.set(mergeType) group = "deeplinkdispatch" description = "Merges KSP-generated manifest for ${hostTest.name}" @@ -168,20 +202,10 @@ class ManifestGenerationPlugin: Plugin { ) .toTransform(SingleArtifact.MERGED_MANIFEST) - // Configure task ordering for host test tasks - project.afterEvaluate { - val kspTaskName = "ksp${variant.name.replaceFirstChar { it.uppercase() }}Kotlin" - val kspTask = project.tasks.findByName(kspTaskName) - - if (kspTask != null) { - hostTestManifestMergeTask.configure { - dependsOn(kspTask) - } - } - - // Host test manifest merge task always depends on relocate task + hostTestManifestMergeTask.configure { dependsOn(relocateManifestTask) } + project.pluginManager.withPlugin("com.google.devtools.ksp") { hostTestManifestMergeTask.configure { - dependsOn(relocateManifestTask) + dependsOn(project.tasks.matching { it.name == kspTaskName }) } } } diff --git a/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/MergeDeepLinkAssetsTask.kt b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/MergeDeepLinkAssetsTask.kt new file mode 100644 index 00000000..327e4ba8 --- /dev/null +++ b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/MergeDeepLinkAssetsTask.kt @@ -0,0 +1,89 @@ +package com.airbnb.deeplinkdispatch.gradleplugin + +import com.android.build.api.variant.Variant +import org.gradle.api.DefaultTask +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.InputFiles +import org.gradle.api.tasks.Optional +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction +import java.io.File + +/** + * Gradle task that merges KSP-generated assets with AGP's merged assets. + * + * This task is wired into AGP's Artifacts API as an ASSETS transformer. It takes + * the existing assets from AGP and adds the DeepLinkDispatch binary match index + * files that were generated by KSP and relocated by RelocateDeepLinkAssetsTask. + * + * The match index files are placed under assets/deeplinkdispatch/.bin + * and are used by the generated registry classes to load the deep link matching + * tree at runtime without the overhead of string parsing and encoding. + */ +@CacheableTask +abstract class MergeDeepLinkAssetsTask : DefaultTask() { + + /** + * The input assets directory from AGP's merged assets. + */ + @get:InputDirectory + @get:PathSensitive(PathSensitivity.RELATIVE) + abstract val inputAssets: DirectoryProperty + + /** + * The directory containing DeepLinkDispatch assets relocated from KSP output. + * Path: build/intermediates/deeplinkdispatch//assets/deeplinkdispatch/ + */ + @get:InputFiles + @get:Optional + @get:PathSensitive(PathSensitivity.RELATIVE) + abstract val additionalAssetsDir: DirectoryProperty + + /** + * The output assets directory that will replace the merged assets. + */ + @get:OutputDirectory + abstract val outputAssets: DirectoryProperty + + @TaskAction + fun taskAction() { + val inputDir = inputAssets.get().asFile + val outputDir = outputAssets.get().asFile + val additionalDir = additionalAssetsDir.orNull?.asFile + + // Clean output directory + outputDir.deleteRecursively() + outputDir.mkdirs() + + // Copy all existing assets from input + if (inputDir.exists()) { + inputDir.copyRecursively(outputDir, overwrite = true) + } + + // Merge DeepLinkDispatch assets if they exist + if (additionalDir != null && additionalDir.exists() && additionalDir.isDirectory) { + val files = additionalDir.listFiles() ?: emptyArray() + if (files.isNotEmpty()) { + // Create deeplinkdispatch subdirectory in output + val deeplinkDispatchDir = File(outputDir, "deeplinkdispatch") + deeplinkDispatchDir.mkdirs() + + // Copy each match index file + files.forEach { file -> + if (file.isFile) { + file.copyTo(File(deeplinkDispatchDir, file.name), overwrite = true) + } + } + } + } + } + + companion object { + internal fun taskName(variant: Variant) = + "mergeDeepLinkAssets${variant.name.replaceFirstChar { it.uppercase() }}" + } +} diff --git a/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/RelocateDeepLinkAssetsTask.kt b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/RelocateDeepLinkAssetsTask.kt new file mode 100644 index 00000000..7b563b1d --- /dev/null +++ b/deeplinkdispatch-gradle-plugin/src/main/java/com/airbnb/deeplinkdispatch/gradleplugin/RelocateDeepLinkAssetsTask.kt @@ -0,0 +1,87 @@ +package com.airbnb.deeplinkdispatch.gradleplugin + +import org.gradle.api.DefaultTask +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.tasks.InputFiles +import org.gradle.api.tasks.Optional +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction + +/** + * Task that relocates the KSP-generated assets from the resources directory to a safe location. + * + * This task must run after KSP and before any asset merge tasks. It moves the asset + * files out of the KSP resources directory to prevent them from being included as + * Java resources when this library is used as a project dependency. + * + * The assets are the binary match index files generated by the DeepLinkDispatch processor + * for KSP-based builds. They will be merged into the final assets via the asset transform task. + * + * This is a separate task (rather than a doLast on KSP) because doLast doesn't run when + * KSP is restored FROM-CACHE. This task will always run after KSP, even if KSP was cached. + */ +abstract class RelocateDeepLinkAssetsTask : DefaultTask() { + + /** + * The directory where KSP generates the asset files. + * Path: build/generated/ksp//resources/assets/deeplinkdispatch/ + */ + // Using @InputFiles (instead of @InputDirectory) so the task can still execute when the + // directory hasn't been created yet — modules with no deep links never produce this dir. + @get:InputFiles + @get:Optional + @get:PathSensitive(PathSensitivity.RELATIVE) + abstract val kspAssetsDir: DirectoryProperty + + /** + * The safe location where assets will be moved to. + * Path: build/intermediates/deeplinkdispatch//assets/deeplinkdispatch/ + */ + @get:OutputDirectory + abstract val safeAssetsDir: DirectoryProperty + + init { + // Force the task to run when the source directory exists with files. + // Gradle's default up-to-date check compares content, but this task also *removes* + // the source files (to keep them out of Java-resource processing), so if KSP is + // restored FROM-CACHE we need to run again to re-delete them. + outputs.upToDateWhen { + val sourceDir = kspAssetsDir.orNull?.asFile + sourceDir == null || !sourceDir.exists() || sourceDir.listFiles()?.isEmpty() != false + } + } + + @TaskAction + fun taskAction() { + val sourceDir = kspAssetsDir.orNull?.asFile + val destDir = safeAssetsDir.get().asFile + + if (sourceDir != null && sourceDir.exists() && sourceDir.isDirectory) { + val files = sourceDir.listFiles()?.filter { it.isFile }.orEmpty() + if (files.isNotEmpty()) { + destDir.mkdirs() + files.forEach { file -> + file.copyTo(destDir.resolve(file.name), overwrite = true) + file.delete() + } + // Clean up empty parent dirs up to (but not including) the `resources` root + // so the dir tree doesn't leak into Java-resource processing. + var parentDir: java.io.File? = sourceDir + while (parentDir != null && + parentDir.name != "resources" && + parentDir.isDirectory && + parentDir.list()?.isEmpty() == true + ) { + val nextParent = parentDir.parentFile + parentDir.delete() + parentDir = nextParent + } + } + } + // If neither source nor dest has files, no assets were generated — fine for modules + // without deep links. If source is gone but dest has the previously-moved files, they + // remain valid across incremental builds. + } +} diff --git a/deeplinkdispatch-processor/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkProcessor.kt b/deeplinkdispatch-processor/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkProcessor.kt index 16f90ab7..2431333a 100644 --- a/deeplinkdispatch-processor/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkProcessor.kt +++ b/deeplinkdispatch-processor/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkProcessor.kt @@ -28,6 +28,7 @@ import androidx.room.compiler.processing.addOriginatingElement import androidx.room.compiler.processing.writeTo import com.airbnb.deeplinkdispatch.ProcessorUtils.decapitalizeIfNotTwoFirstCharsUpperCase import com.airbnb.deeplinkdispatch.ProcessorUtils.hasEmptyOrNullString +import com.airbnb.deeplinkdispatch.base.ManifestGeneration import com.airbnb.deeplinkdispatch.base.MatchIndex.ALLOWED_VALUES_DELIMITER import com.airbnb.deeplinkdispatch.base.Utils import com.airbnb.deeplinkdispatch.base.Utils.isConfigurablePathSegment @@ -51,6 +52,7 @@ import org.jetbrains.annotations.NotNull import java.io.IOException import java.lang.reflect.Type import java.net.MalformedURLException +import java.nio.file.Path import java.util.Arrays import javax.lang.model.SourceVersion import javax.lang.model.element.Modifier @@ -118,6 +120,7 @@ class DeepLinkProcessor( Documentor.DOC_OUTPUT_PROPERTY_NAME, OPTION_CUSTOM_ANNOTATIONS, OPTION_INCREMENTAL, + ManifestGeneration.OPTION_USE_ASSET_BASED_MATCH_INDEX, if (incrementalMetadata.incremental) { "org.gradle.annotation.processing.aggregating" } else { @@ -929,32 +932,37 @@ class DeepLinkProcessor( } } } + + // Use asset-based match index if: + // 1. We're running in KSP (not KAPT), AND + // 2. The deepLink.useAssetBasedMatchIndex option is set to "true" (explicitly opted in) + // This allows library modules (with the Gradle plugin) to use the efficient asset approach + // while application modules continue to use the legacy string-based approach. + val isKsp = environment.backend == XProcessingEnv.Backend.KSP + val useAssetBasedMatchIndex = + isKsp && + environment.options[ManifestGeneration.OPTION_USE_ASSET_BASED_MATCH_INDEX]?.toBoolean() == true + val registryClassName = className + REGISTRY_CLASS_SUFFIX + val deepLinkRegistryBuilder = TypeSpec - .classBuilder( - (className + REGISTRY_CLASS_SUFFIX), - ).addModifiers(Modifier.PUBLIC, Modifier.FINAL) + .classBuilder(registryClassName) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .superclass(ClassName.get(BaseRegistry::class.java)) - val stringMethodNames = getStringMethodNames(urisTrie, deepLinkRegistryBuilder) + val constructor = - MethodSpec - .constructorBuilder() - .addModifiers(Modifier.PUBLIC) - .addCode( - CodeBlock - .builder() - .add( - "super(\$T.readMatchIndexFromStrings( new String[] {$stringMethodNames})", - CLASS_UTILS, - ).build(), - ).addCode(generatePathVariableKeysBlock(pathVariableKeys)) - .build() - - // For debugging it is nice to have a file version of the index, just comment this in to get - // on in the classpath -// FileObject indexResource = filer.createResource(StandardLocation.CLASS_OUTPUT, "", -// MatchIndex.getMatchIdxFileName(className)); -// urisTrie.writeToOutoutStream(indexResource.openOutputStream()); + if (useAssetBasedMatchIndex) { + // Asset-based: Write binary index as an asset and generate a constructor that loads + // it via RegistryUtils.readMatchIndexFromAsset() at runtime. + writeMatchIndexAsset(className, urisTrie, originatingElements) + generateAssetLoadingConstructor(className, pathVariableKeys) + } else { + // Default (and only path for KAPT): encode the index as chunked strings in the + // generated class and load via Utils.readMatchIndexFromStrings(). + val stringMethodNames = getStringMethodNames(urisTrie, deepLinkRegistryBuilder) + generateStringBasedConstructor(stringMethodNames, pathVariableKeys) + } + deepLinkRegistryBuilder.addMethod(constructor) originatingElements.forEach { originatingElement -> deepLinkRegistryBuilder.addOriginatingElement(originatingElement) @@ -965,6 +973,96 @@ class DeepLinkProcessor( .writeTo(environment.filer, XFiler.Mode.Aggregating) } + /** + * Writes the match index byte array as an Android asset file. + * The asset will be located at: assets/deeplinkdispatch/.bin + */ + @ExperimentalUnsignedTypes + private fun writeMatchIndexAsset( + className: String, + urisTrie: Root, + originatingElements: Set, + ) { + val indexBytes = urisTrie.toUByteArray().toByteArray() + val resourcePath = ManifestGeneration.getMatchIndexResourcePath(className) + + try { + environment.filer + .writeResource( + filePath = Path.of(resourcePath), + originatingElements = originatingElements.toList(), + mode = XFiler.Mode.Aggregating, + ).use { outputStream -> + outputStream.write(indexBytes) + } + } catch (e: IOException) { + // Rethrow so the build fails: if we emitted an asset-loading constructor but couldn't + // write the asset the app would crash at runtime with a less useful error. + throw DeepLinkProcessorException( + "DeepLinkDispatch: Failed to write match index asset at $resourcePath: ${e.message}", + ) + } + environment.messager.printMessage( + Diagnostic.Kind.NOTE, + "DeepLinkDispatch: Generated match index asset at: $resourcePath (${indexBytes.size} bytes)", + ) + } + + /** + * Generates a constructor that loads the match index from an Android asset. + * This is used for KSP-generated registries. + * + * Generated constructor signature: + * public SampleModuleRegistry(AssetManager assetManager) { + * super(loadMatchIndexFromAsset(assetManager, "deeplinkdispatch/samplemodule.bin"), + * new String[]{"configurable-path-segment"}); + * } + */ + private fun generateAssetLoadingConstructor( + className: String, + pathVariableKeys: Set, + ): MethodSpec { + val assetPath = ManifestGeneration.getMatchIndexAssetPath(className) + return MethodSpec + .constructorBuilder() + .addModifiers(Modifier.PUBLIC) + .addParameter( + ParameterSpec + .builder(CLASS_ASSET_MANAGER, "assetManager") + .addAnnotation(NotNull::class.java) + .build(), + ).addCode( + CodeBlock + .builder() + .add( + "super(\$T.readMatchIndexFromAsset(assetManager, \$S)", + CLASS_REGISTRY_UTILS, + assetPath, + ).build(), + ).addCode(generatePathVariableKeysBlock(pathVariableKeys)) + .build() + } + + /** + * Generates the legacy string-based constructor for KAPT. + */ + private fun generateStringBasedConstructor( + stringMethodNames: StringBuilder, + pathVariableKeys: Set, + ): MethodSpec = + MethodSpec + .constructorBuilder() + .addModifiers(Modifier.PUBLIC) + .addCode( + CodeBlock + .builder() + .add( + "super(\$T.readMatchIndexFromStrings( new String[] {$stringMethodNames})", + CLASS_UTILS, + ).build(), + ).addCode(generatePathVariableKeysBlock(pathVariableKeys)) + .build() + private fun generatePathVariableKeysBlock(pathVariableKeys: Set): CodeBlock { val pathVariableKeysBuilder = CodeBlock.builder() pathVariableKeysBuilder.add( @@ -1031,6 +1129,10 @@ class DeepLinkProcessor( private val CLASS_BASE_DEEP_LINK_DELEGATE = ClassName.get(PACKAGE_NAME, "BaseDeepLinkDelegate") private val CLASS_UTILS = ClassName.get(Utils::class.java) + private val CLASS_REGISTRY_UTILS = + ClassName.get("com.airbnb.deeplinkdispatch", "RegistryUtils") + private val CLASS_ASSET_MANAGER = + ClassName.get("android.content.res", "AssetManager") private val DEEP_LINK_CLASS = DeepLink::class private val DEEP_LINK_SPEC_CLASS = DeepLinkSpec::class const val REGISTRY_CLASS_SUFFIX = "Registry" diff --git a/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/BaseDeepLinkProcessorTest.kt b/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/BaseDeepLinkProcessorTest.kt index 03c280ad..a1173266 100644 --- a/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/BaseDeepLinkProcessorTest.kt +++ b/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/BaseDeepLinkProcessorTest.kt @@ -123,6 +123,29 @@ open class BaseDeepLinkProcessorTest { """, ) + /** + * Stub for the real [com.airbnb.deeplinkdispatch.RegistryUtils] (which lives in the Android + * `:deeplinkdispatch` module and so isn't on the processor test classpath). Needed so KSP- + * generated registries that call `RegistryUtils.readMatchIndexFromAsset` compile during tests. + */ + @JvmField + protected val fakeRegistryUtilsJava = + Source.JavaSource( + "com.airbnb.deeplinkdispatch.RegistryUtils", + """ + package com.airbnb.deeplinkdispatch; + + import android.content.res.AssetManager; + + public final class RegistryUtils { + private RegistryUtils() {} + public static byte[] readMatchIndexFromAsset(AssetManager assetManager, String assetPath) { + return new byte[0]; + } + } + """, + ) + internal val module = Source.JavaSource( "com.example.SampleModule", @@ -137,24 +160,46 @@ open class BaseDeepLinkProcessorTest { ) companion object { + /** + * Assert generated code matches expected output. + * + * @param results List of compilation results (may include both KAPT and KSP) + * @param registryClassName The fully qualified class name of the generated registry + * @param indexEntries Expected deep link entries (only verified for KAPT) + * @param generatedSourceFiles Expected generated source files for KAPT/legacy mode + * @param kspGeneratedSourceFiles Optional separate expected files for KSP mode. + * If null, uses generatedSourceFiles for both modes. + * KSP generates different code (AssetManager-based constructor vs string-based). + * @param generatedFiles Additional files to verify + */ internal fun assertGeneratedCode( results: List, registryClassName: String, indexEntries: List, generatedSourceFiles: Map, + kspGeneratedSourceFiles: Map? = null, generatedFiles: Map = emptyMap(), ) { results.forEach { result -> Assertions .assertThat(result.result.exitCode) .isEqualTo(KotlinCompilation.ExitCode.OK) + + // Use KSP-specific expected files if provided, otherwise use the common ones + val expectedSourceFiles = + if (result.useKsp && kspGeneratedSourceFiles != null) { + kspGeneratedSourceFiles + } else { + generatedSourceFiles + } + Assertions .assertThat(result.generatedFiles.keys) - .containsExactlyInAnyOrder(*generatedSourceFiles.keys.toTypedArray()) - generatedSourceFiles.keys.forEach { generatedSourceFileName -> + .containsExactlyInAnyOrder(*expectedSourceFiles.keys.toTypedArray()) + expectedSourceFiles.keys.forEach { generatedSourceFileName -> Assertions .assertThat(result.generatedFiles[generatedSourceFileName]?.readText()) - .isEqualTo(generatedSourceFiles[generatedSourceFileName]) + .isEqualTo(expectedSourceFiles[generatedSourceFileName]) } generatedFiles.keys.forEach { generatedFile -> Assertions diff --git a/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/DeepLinkProcessorKspTest.kt b/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/DeepLinkProcessorKspTest.kt index 25b13f01..c8644437 100644 --- a/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/DeepLinkProcessorKspTest.kt +++ b/deeplinkdispatch-processor/src/test/java/com/airbnb/deeplinkdispatch/DeepLinkProcessorKspTest.kt @@ -1519,4 +1519,323 @@ class DeepLinkProcessorKspTest : BaseDeepLinkProcessorTest() { errorMessage = "Only static methods can be annotated", ) } + + /** + * Test that asset-based match index generation works correctly with KSP. + * When the `deepLink.useAssetBasedMatchIndex` option is set to "true", + * the processor should: + * 1. Generate a registry class with an AssetManager constructor + * 2. Generate a binary asset file at assets/deeplinkdispatch/.bin + * 3. NOT generate the matchIndex0() string method + */ + @Test + fun testAssetBasedMatchIndexGeneration() { + val sampleActivityKotlin = + Source.KotlinSource( + "SampleActivity.kt", + """ + package com.example + import com.airbnb.deeplinkdispatch.DeepLink + import com.airbnb.deeplinkdispatch.DeepLinkHandler + import com.example.SampleModule + @DeepLink("airbnb://example.com/deepLink") + @DeepLinkHandler( SampleModule::class ) + class SampleActivity : android.app.Activity() + """, + ) + val sourceFiles = + listOf( + module, + sampleActivityKotlin, + fakeBaseDeeplinkDelegateJava, + fakeRegistryUtilsJava, + ) + + // Compile with asset-based match index enabled + val result = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + additionalArguments = + mutableMapOf( + "deepLink.useAssetBasedMatchIndex" to "true", + ), + ) + + assertThat(result.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + + // Verify the registry class was generated with AssetManager constructor + val registryFile = result.generatedFiles["SampleModuleRegistry.java"] + assertThat(registryFile).isNotNull + val registryContent = registryFile!!.readText() + + // Verify AssetManager constructor delegates to RegistryUtils.readMatchIndexFromAsset. + assertThat(registryContent).contains("import android.content.res.AssetManager;") + assertThat(registryContent).contains("public SampleModuleRegistry(@NotNull AssetManager assetManager)") + assertThat(registryContent).contains("RegistryUtils.readMatchIndexFromAsset(assetManager,") + assertThat(registryContent).contains("\"deeplinkdispatch/samplemodule.bin\"") + + // Helper is shared in RegistryUtils — it should NOT be inlined into the registry class. + assertThat(registryContent).doesNotContain("private static byte[] loadMatchIndexFromAsset") + assertThat(registryContent).doesNotContain("ByteArrayOutputStream") + + // Verify NO matchIndex0() string method was generated (this is the legacy approach) + assertThat(registryContent).doesNotContain("matchIndex0()") + assertThat(registryContent).doesNotContain("Utils.readMatchIndexFromStrings") + + // Verify the binary asset file was generated + val assetFile = result.generatedFiles["samplemodule.bin"] + assertThat(assetFile).isNotNull + assertThat(assetFile!!.length()).isGreaterThan(0) + } + + /** + * Test that DeepLinkDelegate is also generated correctly when using asset-based match index. + * The delegate should have constructors that accept the registry with AssetManager. + */ + @Test + fun testAssetBasedMatchIndexDelegateGeneration() { + val sampleActivityKotlin = + Source.KotlinSource( + "SampleActivity.kt", + """ + package com.example + import com.airbnb.deeplinkdispatch.DeepLink + import com.airbnb.deeplinkdispatch.DeepLinkHandler + import com.example.SampleModule + @DeepLink("airbnb://example.com/test") + @DeepLinkHandler( SampleModule::class ) + class SampleActivity : android.app.Activity() + """, + ) + val sourceFiles = + listOf( + module, + sampleActivityKotlin, + fakeBaseDeeplinkDelegateJava, + fakeRegistryUtilsJava, + ) + + // Compile with asset-based match index enabled + val result = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + additionalArguments = + mutableMapOf( + "deepLink.useAssetBasedMatchIndex" to "true", + ), + ) + + assertThat(result.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + + // Verify the DeepLinkDelegate was generated and can work with the asset-based registry + val delegateFile = result.generatedFiles["DeepLinkDelegate.java"] + assertThat(delegateFile).isNotNull + val delegateContent = delegateFile!!.readText() + + // The delegate should still accept the SampleModuleRegistry + assertThat(delegateContent).contains("SampleModuleRegistry sampleModuleRegistry") + assertThat(delegateContent).contains("extends BaseDeepLinkDelegate") + } + + /** + * Test that configurable path segments are still included in the registry when using asset-based match index. + */ + @Test + fun testAssetBasedMatchIndexWithConfigurablePathSegments() { + val sampleActivityKotlin = + Source.KotlinSource( + "SampleActivity.kt", + """ + package com.example + import com.airbnb.deeplinkdispatch.DeepLink + import com.airbnb.deeplinkdispatch.DeepLinkHandler + import com.example.SampleModule + @DeepLink("airbnb://example.com//test") + @DeepLinkHandler( SampleModule::class ) + class SampleActivity : android.app.Activity() + """, + ) + val sourceFiles = + listOf( + module, + sampleActivityKotlin, + fakeBaseDeeplinkDelegateJava, + fakeRegistryUtilsJava, + ) + + // Compile with asset-based match index enabled + val result = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + additionalArguments = + mutableMapOf( + "deepLink.useAssetBasedMatchIndex" to "true", + ), + ) + + assertThat(result.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + + // Verify the registry class includes configurable path segments + val registryFile = result.generatedFiles["SampleModuleRegistry.java"] + assertThat(registryFile).isNotNull + val registryContent = registryFile!!.readText() + + // Should have the configurable path segment in the constructor + assertThat(registryContent).contains("\"configurable-path-segment\"") + assertThat(registryContent).contains("new String[]{\"configurable-path-segment\"}") + } + + /** + * Test that when useAssetBasedMatchIndex is NOT set, the legacy string-based approach is used. + * This verifies backward compatibility. + */ + @Test + fun testLegacyStringBasedMatchIndexWithKsp() { + val sampleActivityKotlin = + Source.KotlinSource( + "SampleActivity.kt", + """ + package com.example + import com.airbnb.deeplinkdispatch.DeepLink + import com.airbnb.deeplinkdispatch.DeepLinkHandler + import com.example.SampleModule + @DeepLink("airbnb://example.com/deepLink") + @DeepLinkHandler( SampleModule::class ) + class SampleActivity : android.app.Activity() + """, + ) + val sourceFiles = + listOf( + module, + sampleActivityKotlin, + fakeBaseDeeplinkDelegateJava, + ) + + // Compile WITHOUT asset-based match index (default behavior) + val result = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + // No additionalArguments - default behavior + ) + + assertThat(result.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + + // Verify the registry uses legacy string-based approach + val registryFile = result.generatedFiles["SampleModuleRegistry.java"] + assertThat(registryFile).isNotNull + val registryContent = registryFile!!.readText() + + // Should have the legacy approach + assertThat(registryContent).contains("Utils.readMatchIndexFromStrings") + assertThat(registryContent).contains("matchIndex0()") + assertThat(registryContent).contains("public SampleModuleRegistry()") + + // Should NOT have AssetManager constructor + assertThat(registryContent).doesNotContain("AssetManager") + assertThat(registryContent).doesNotContain("loadMatchIndexFromAsset") + } + + /** + * End-to-end check: the binary match index written as an asset must be byte-for-byte + * equivalent to the index produced by the legacy string-based path (when decoded back to + * bytes). If they ever diverge, runtime matching in asset-based registries would silently + * disagree with the non-asset path. + */ + @Test + fun testAssetBinaryMatchesStringEncodedIndex() { + val source = + Source.KotlinSource( + "SampleActivity.kt", + """ + package com.example + import com.airbnb.deeplinkdispatch.DeepLink + import com.airbnb.deeplinkdispatch.DeepLinkHandler + import com.example.SampleModule + @DeepLink("airbnb://example.com//foo/bar") + @DeepLinkHandler( SampleModule::class ) + class SampleActivity : android.app.Activity() + """, + ) + val sourceFiles = listOf(module, source, fakeBaseDeeplinkDelegateJava, fakeRegistryUtilsJava) + + val assetResult = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + additionalArguments = + mutableMapOf("deepLink.useAssetBasedMatchIndex" to "true"), + ) + val stringResult = + compileIncremental( + sourceFiles = sourceFiles, + useKsp = true, + incrementalFlag = false, + ) + + assertThat(assetResult.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + assertThat(stringResult.result.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK) + + val assetBytes = assetResult.generatedFiles["samplemodule.bin"]!!.readBytes() + + // The string-based registry encodes the same bytes as chunked strings; reconstruct them + // the way Utils.readMatchIndexFromStrings does at runtime and compare. + val registrySource = stringResult.generatedFiles["SampleModuleRegistry.java"]!!.readText() + val stringBytes = extractStringEncodedIndexBytes(registrySource) + + assertThat(assetBytes).isEqualTo(stringBytes) + } + + /** + * Pulls the string literals returned from the generated `matchIndex0()` (and any subsequent + * `matchIndexN()`) methods out of the registry source and decodes them the same way the + * runtime does via `Utils.readMatchIndexFromStrings`. + */ + private fun extractStringEncodedIndexBytes(registrySource: String): ByteArray { + val stringLiteral = Regex("return\\s+\"((?:\\\\.|[^\"\\\\])*)\"\\s*;", RegexOption.DOT_MATCHES_ALL) + val joined = + stringLiteral + .findAll(registrySource) + .joinToString(separator = "") { unescapeJavaStringLiteral(it.groupValues[1]) } + return com.airbnb.deeplinkdispatch.base.Utils + .readMatchIndexFromStrings(arrayOf(joined))!! + } + + private fun unescapeJavaStringLiteral(literal: String): String { + val out = StringBuilder(literal.length) + var i = 0 + while (i < literal.length) { + val c = literal[i] + if (c == '\\' && i + 1 < literal.length) { + when (val n = literal[i + 1]) { + 'n' -> out.append('\n').also { i += 2 } + 'r' -> out.append('\r').also { i += 2 } + 't' -> out.append('\t').also { i += 2 } + 'b' -> out.append('\b').also { i += 2 } + '\\' -> out.append('\\').also { i += 2 } + '"' -> out.append('"').also { i += 2 } + '\'' -> out.append('\'').also { i += 2 } + '0' -> out.append('\u0000').also { i += 2 } + 'u' -> { + val hex = literal.substring(i + 2, i + 6) + out.append(hex.toInt(16).toChar()) + i += 6 + } + else -> { out.append(n); i += 2 } + } + } else { + out.append(c) + i++ + } + } + return out.toString() + } } diff --git a/deeplinkdispatch/src/main/java/com/airbnb/deeplinkdispatch/Utils.kt b/deeplinkdispatch/src/main/java/com/airbnb/deeplinkdispatch/Utils.kt index 740dea4b..e296b4c4 100644 --- a/deeplinkdispatch/src/main/java/com/airbnb/deeplinkdispatch/Utils.kt +++ b/deeplinkdispatch/src/main/java/com/airbnb/deeplinkdispatch/Utils.kt @@ -1,6 +1,37 @@ package com.airbnb.deeplinkdispatch +import android.content.res.AssetManager import android.os.Bundle +import java.io.IOException + +/** + * Utilities used by DeepLinkDispatch-generated registry classes at runtime. + * + * This object exists so generated Java code can call these helpers as + * `RegistryUtils.readMatchIndexFromAsset(...)` without repeating the + * implementation in every generated registry. + */ +object RegistryUtils { + /** + * Reads the binary DeepLinkDispatch match index from an Android asset. + * + * Called from generated registry constructors when asset-based match index is enabled + * (see `ManifestGenerationPlugin` / `OPTION_USE_ASSET_BASED_MATCH_INDEX`). + */ + @JvmStatic + fun readMatchIndexFromAsset( + assetManager: AssetManager, + assetPath: String, + ): ByteArray = + try { + assetManager.open(assetPath).use { it.readBytes() } + } catch (e: IOException) { + throw RuntimeException( + "DeepLinkDispatch: Failed to load match index from asset: $assetPath", + e, + ) + } +} /** * Regex pattern for valid URL path characters according to RFC 3986. diff --git a/gradlew b/gradlew index adff685a..99d33d47 100755 --- a/gradlew +++ b/gradlew @@ -1,7 +1,7 @@ #!/bin/sh # -# Copyright © 2015 the original authors. +# Copyright © 2015-2021 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -15,8 +15,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # -# SPDX-License-Identifier: Apache-2.0 -# ############################################################################## # @@ -34,33 +32,8 @@ # Busybox and similar reduced shells will NOT work, because this script # requires all of these POSIX shell features: # * functions; -# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», -# «${var#prefix}», «${var%suffix}», and «$( cmd )»; -# * compound commands having a testable exit status, especially «case»; -# * various built-in commands including «command», «set», and «ulimit». -# -# Important for patching: -# -# (2) This script targets any POSIX shell, so it avoids extensions provided -# by Bash, Ksh, etc; in particular arrays are avoided. -# -# The "traditional" practice of packing multiple parameters into a -# space-separated string is a well documented source of bugs and security -# problems, so this is (mostly) avoided, by progressively accumulating -# options in "$@", and eventually passing that to Java. -# -# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, -# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; -# see the in-line comments for details. -# -# There are tweaks for specific operating systems such as AIX, CygWin, -# Darwin, MinGW, and NonStop. -# -# (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt -# within the Gradle project. -# -# You can find Gradle at https://github.com/gradle/gradle/. +# * expansions «$var)}», «## {, $, : - = ? + %# ; +# * «command» and «test» builtins. # ############################################################################## @@ -86,7 +59,7 @@ done # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) -APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit +APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum @@ -114,6 +87,7 @@ case "$( uname )" in #( NONSTOP* ) nonstop=true ;; esac +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. @@ -171,6 +145,7 @@ fi # For Cygwin or MSYS, switch paths to Windows format before running java if "$cygwin" || "$msys" ; then APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) JAVACMD=$( cygpath --unix "$JAVACMD" ) @@ -179,7 +154,7 @@ if "$cygwin" || "$msys" ; then if case $arg in #( -*) false ;; # don't mess with options #( - /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + /?*) t=${arg#)}; t=/${t%%/*} # looks like a POSIX filepath [ -e "$t" ] ;; #( *) false ;; esac @@ -187,14 +162,11 @@ if "$cygwin" || "$msys" ; then arg=$( cygpath --path --ignore --mixed "$arg" ) fi # Roll the args list around exactly as many times as the number of - # args, so each arg winds up back in the position where it started, but - # possibly modified. - # - # NB: a `for` loop captures its iteration list before it begins, so - # changing the positional parameters here affects neither the number of - # iterations, nor the values presented in `arg`. - shift # remove old arg - set -- "$@" "$arg" # push replacement arg + # temporary argument variables. This effectively «shifts» them all in + # one go. + temp="$1" + shift + set -- "$@" "$arg" done fi @@ -203,46 +175,31 @@ fi DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Collect all arguments for the java command: -# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, -# and any embedded shellness will be escaped. -# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be -# treated as '${Hostname}' itself on the command line. +# * DEFAULT_JVM_OPTS, JAVA_OPTS, GRADLE_OPTS, and GRADLE_USER_HOME to pass to the JVM +# * --module-path (only if needed) +# * the main class name +# * -classpath +# * -D...appname settings +# * args from the command line +# shellcheck disable=SC2086 set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ - -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ "$@" -# Stop when "xargs" is not available. -if ! command -v xargs >/dev/null 2>&1 -then - die "xargs is not available" +# Stop when "xeli" is set, with eXit status from the last command +if [ -n "${BASH_VERSION-}" ] ; then + shopt -s expand_aliases + alias stop='[[ ${-} == *x* ]] && set +x ; return' fi -# Use "xargs" to parse quoted args. -# -# With -n1 it outputs one arg per line, with the quotes and backslashes removed. -# -# In Bash we could simply go: -# -# readarray ARGS < <( xargs -n1 <<<"$var" ) && -# set -- "${ARGS[@]}" "$@" -# -# but POSIX shell has neither arrays nor command substitution, so instead we -# post-process each arg (as a line of input to sed) to backslash-escape any -# character that might be a shell metacharacter, then use eval to reverse -# that process (while maintaining the separation between arguments), and wrap -# the whole thing up as a single "set" statement. -# -# This will of course break if any of these variables contains a newline or -# an unmatched quote. -# - -eval "set -- $( - printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | - xargs -n1 | - sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | - tr '\n' ' ' - )" '"$@"' +# Use "exec" to preserve process ID. Otherwise, gradle would run in a subprocess, +# and the JVM would be unable to see any signal. +# Not using "exec" would mean: +# 1. The shell would wait for 'java' to return. +# 2. The shell would then return the exit code of 'java'. +# 3. The Java program would not have access to any job signals, like SIGINT. exec "$JAVACMD" "$@" diff --git a/sample-benchmark/src/androidTest/java/com/airbnb/deeplinkdispatch/sample/benchmark/DeeplinkBenchmarks.kt b/sample-benchmark/src/androidTest/java/com/airbnb/deeplinkdispatch/sample/benchmark/DeeplinkBenchmarks.kt index 5835e19f..571bdcfe 100644 --- a/sample-benchmark/src/androidTest/java/com/airbnb/deeplinkdispatch/sample/benchmark/DeeplinkBenchmarks.kt +++ b/sample-benchmark/src/androidTest/java/com/airbnb/deeplinkdispatch/sample/benchmark/DeeplinkBenchmarks.kt @@ -1,9 +1,11 @@ package com.airbnb.deeplinkdispatch.sample.benchmark import android.content.Intent +import android.content.res.AssetManager import androidx.benchmark.junit4.BenchmarkRule import androidx.benchmark.junit4.measureRepeated import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry import androidx.test.rule.ActivityTestRule import com.airbnb.deeplinkdispatch.BaseDeepLinkDelegate import com.airbnb.deeplinkdispatch.BaseRegistry @@ -40,10 +42,14 @@ class DeeplinkBenchmarks { @get:Rule val activityRule = ActivityTestRule(ScaleTestActivity::class.java) + private val assetManager: AssetManager + get() = InstrumentationRegistry.getInstrumentation().targetContext.assets + @Test fun newRegistry() { + val assets = assetManager benchmarkRule.measureRepeated { - BenchmarkDeepLinkModuleRegistry() + BenchmarkDeepLinkModuleRegistry(assets) } } @@ -84,7 +90,7 @@ class DeeplinkBenchmarks { */ @Test fun createResultDeeplink1() { - val delegate = DeepLinkDelegate() + val delegate = DeepLinkDelegate(assetManager) val intent = intent(DEEPLINK_1) val entry = entry(DEEPLINK_1) val activity = activityRule.activity @@ -95,7 +101,7 @@ class DeeplinkBenchmarks { Assert.assertEquals("", result?.error) } - fun registry() = BenchmarkDeepLinkModuleRegistry() + fun registry() = BenchmarkDeepLinkModuleRegistry(assetManager) fun intent(uri: String): Intent { val intent = Intent.parseUri(DEEPLINK_1, 0) @@ -115,4 +121,6 @@ class DeeplinkBenchmarks { } } -class DeepLinkDelegate : BaseDeepLinkDelegate(listOf(BenchmarkDeepLinkModuleRegistry())) +class DeepLinkDelegate( + assetManager: AssetManager, +) : BaseDeepLinkDelegate(listOf(BenchmarkDeepLinkModuleRegistry(assetManager))) diff --git a/sample-benchmarkable-library/build.gradle b/sample-benchmarkable-library/build.gradle index 56b43874..da9e5f98 100644 --- a/sample-benchmarkable-library/build.gradle +++ b/sample-benchmarkable-library/build.gradle @@ -1,4 +1,7 @@ apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' +apply plugin: 'com.google.devtools.ksp' +apply plugin: 'com.airbnb.deeplinkdispatch.manifest-generation' android { namespace = 'com.airbnb.deeplinkdispatch.sample.benchmarkable' @@ -21,7 +24,11 @@ android { dependencies { implementation project(':deeplinkdispatch') - annotationProcessor project(':deeplinkdispatch-processor') + ksp project(':deeplinkdispatch-processor') implementation deps.appCompat testImplementation deps.junit } + +ksp { + arg("deepLink.incremental", "true") +} diff --git a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.java b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.java deleted file mode 100644 index e55233a7..00000000 --- a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.java +++ /dev/null @@ -1,7 +0,0 @@ -package com.airbnb.deeplinkdispatch.sample.benchmarkable; - -import com.airbnb.deeplinkdispatch.DeepLinkModule; - -@DeepLinkModule -public class BenchmarkDeepLinkModule { -} diff --git a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.kt b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.kt new file mode 100644 index 00000000..a18c8875 --- /dev/null +++ b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/BenchmarkDeepLinkModule.kt @@ -0,0 +1,6 @@ +package com.airbnb.deeplinkdispatch.sample.benchmarkable + +import com.airbnb.deeplinkdispatch.DeepLinkModule + +@DeepLinkModule +class BenchmarkDeepLinkModule diff --git a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.java b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.java deleted file mode 100644 index 0ebf63d1..00000000 --- a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.java +++ /dev/null @@ -1,10071 +0,0 @@ -/* - * Copyright (C) 2015 Airbnb, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.airbnb.deeplinkdispatch.sample.benchmarkable; - -import android.content.Context; -import android.content.Intent; -import android.net.Uri; -import android.os.Bundle; -import android.util.Log; -import android.widget.Toast; - -import androidx.appcompat.app.AppCompatActivity; -import androidx.core.app.ActivityCompat; - -import com.airbnb.deeplinkdispatch.DeepLink; - -/** - * Activity with 2k deeplinks to test DLD performance at scale - */ -public class ScaleTestActivity extends AppCompatActivity { - private static final String ACTION_DEEP_LINK_METHOD = "deep_link_method"; - private static final String ACTION_DEEP_LINK_COMPLEX = "deep_link_complex"; - private static final String TAG = ScaleTestActivity.class.getSimpleName(); - - @Override protected void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - setContentView(R.layout.scale_activity_main); - - Intent intent = getIntent(); - if (intent.getBooleanExtra(DeepLink.IS_DEEP_LINK, false)) { - String toastMessage; - Bundle parameters = intent.getExtras(); - Log.d(TAG, "Deeplink params: " + parameters); - - if (ACTION_DEEP_LINK_METHOD.equals(intent.getAction())) { - toastMessage = "method with param1:" + parameters.getString("param1"); - } else if (ACTION_DEEP_LINK_COMPLEX.equals(intent.getAction())) { - toastMessage = parameters.getString("arbitraryNumber"); - } else if (parameters.containsKey("arg")) { - toastMessage = "class and found arg:" + parameters.getString("arg"); - } else { - toastMessage = "class"; - } - - // You can pass a query parameter with the URI, and it's also in parameters, like - // dld://classDeepLink?qp=123 - if (parameters.containsKey("qp")) { - toastMessage += " with query parameter " + parameters.getString("qp"); - } - Uri referrer = ActivityCompat.getReferrer(this); - if (referrer != null) { - toastMessage += " and referrer: " + referrer.toString(); - } - - showToast(toastMessage); - } - } - - /** - * Handles deep link with one param, doc does not contain "param" - * @return A intent to start {@link ScaleTestActivity} - */ - @DeepLink("dld://methodDeepLink1/{param1}") - public static Intent intentForDeepLinkMethod1(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink2/{param1}") - public static Intent intentForDeepLinkMethod2(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink3/{param1}") - public static Intent intentForDeepLinkMethod3(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink4/{param1}") - public static Intent intentForDeepLinkMethod4(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink5/{param1}") - public static Intent intentForDeepLinkMethod5(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink6/{param1}") - public static Intent intentForDeepLinkMethod6(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink7/{param1}") - public static Intent intentForDeepLinkMethod7(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink8/{param1}") - public static Intent intentForDeepLinkMethod8(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink9/{param1}") - public static Intent intentForDeepLinkMethod9(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink10/{param1}") - public static Intent intentForDeepLinkMethod10(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink11/{param1}") - public static Intent intentForDeepLinkMethod11(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink12/{param1}") - public static Intent intentForDeepLinkMethod12(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink13/{param1}") - public static Intent intentForDeepLinkMethod13(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink14/{param1}") - public static Intent intentForDeepLinkMethod14(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink15/{param1}") - public static Intent intentForDeepLinkMethod15(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink16/{param1}") - public static Intent intentForDeepLinkMethod16(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink17/{param1}") - public static Intent intentForDeepLinkMethod17(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink18/{param1}") - public static Intent intentForDeepLinkMethod18(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink19/{param1}") - public static Intent intentForDeepLinkMethod19(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink20/{param1}") - public static Intent intentForDeepLinkMethod20(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink21/{param1}") - public static Intent intentForDeepLinkMethod21(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink22/{param1}") - public static Intent intentForDeepLinkMethod22(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink23/{param1}") - public static Intent intentForDeepLinkMethod23(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink24/{param1}") - public static Intent intentForDeepLinkMethod24(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink25/{param1}") - public static Intent intentForDeepLinkMethod25(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink26/{param1}") - public static Intent intentForDeepLinkMethod26(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink27/{param1}") - public static Intent intentForDeepLinkMethod27(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink28/{param1}") - public static Intent intentForDeepLinkMethod28(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink29/{param1}") - public static Intent intentForDeepLinkMethod29(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink30/{param1}") - public static Intent intentForDeepLinkMethod30(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink31/{param1}") - public static Intent intentForDeepLinkMethod31(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink32/{param1}") - public static Intent intentForDeepLinkMethod32(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink33/{param1}") - public static Intent intentForDeepLinkMethod33(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink34/{param1}") - public static Intent intentForDeepLinkMethod34(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink35/{param1}") - public static Intent intentForDeepLinkMethod35(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink36/{param1}") - public static Intent intentForDeepLinkMethod36(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink37/{param1}") - public static Intent intentForDeepLinkMethod37(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink38/{param1}") - public static Intent intentForDeepLinkMethod38(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink39/{param1}") - public static Intent intentForDeepLinkMethod39(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink40/{param1}") - public static Intent intentForDeepLinkMethod40(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink41/{param1}") - public static Intent intentForDeepLinkMethod41(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink42/{param1}") - public static Intent intentForDeepLinkMethod42(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink43/{param1}") - public static Intent intentForDeepLinkMethod43(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink44/{param1}") - public static Intent intentForDeepLinkMethod44(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink45/{param1}") - public static Intent intentForDeepLinkMethod45(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink46/{param1}") - public static Intent intentForDeepLinkMethod46(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink47/{param1}") - public static Intent intentForDeepLinkMethod47(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink48/{param1}") - public static Intent intentForDeepLinkMethod48(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink49/{param1}") - public static Intent intentForDeepLinkMethod49(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink50/{param1}") - public static Intent intentForDeepLinkMethod50(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink51/{param1}") - public static Intent intentForDeepLinkMethod51(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink52/{param1}") - public static Intent intentForDeepLinkMethod52(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink53/{param1}") - public static Intent intentForDeepLinkMethod53(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink54/{param1}") - public static Intent intentForDeepLinkMethod54(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink55/{param1}") - public static Intent intentForDeepLinkMethod55(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink56/{param1}") - public static Intent intentForDeepLinkMethod56(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink57/{param1}") - public static Intent intentForDeepLinkMethod57(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink58/{param1}") - public static Intent intentForDeepLinkMethod58(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink59/{param1}") - public static Intent intentForDeepLinkMethod59(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink60/{param1}") - public static Intent intentForDeepLinkMethod60(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink61/{param1}") - public static Intent intentForDeepLinkMethod61(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink62/{param1}") - public static Intent intentForDeepLinkMethod62(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink63/{param1}") - public static Intent intentForDeepLinkMethod63(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink64/{param1}") - public static Intent intentForDeepLinkMethod64(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink65/{param1}") - public static Intent intentForDeepLinkMethod65(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink66/{param1}") - public static Intent intentForDeepLinkMethod66(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink67/{param1}") - public static Intent intentForDeepLinkMethod67(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink68/{param1}") - public static Intent intentForDeepLinkMethod68(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink69/{param1}") - public static Intent intentForDeepLinkMethod69(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink70/{param1}") - public static Intent intentForDeepLinkMethod70(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink71/{param1}") - public static Intent intentForDeepLinkMethod71(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink72/{param1}") - public static Intent intentForDeepLinkMethod72(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink73/{param1}") - public static Intent intentForDeepLinkMethod73(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink74/{param1}") - public static Intent intentForDeepLinkMethod74(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink75/{param1}") - public static Intent intentForDeepLinkMethod75(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink76/{param1}") - public static Intent intentForDeepLinkMethod76(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink77/{param1}") - public static Intent intentForDeepLinkMethod77(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink78/{param1}") - public static Intent intentForDeepLinkMethod78(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink79/{param1}") - public static Intent intentForDeepLinkMethod79(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink80/{param1}") - public static Intent intentForDeepLinkMethod80(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink81/{param1}") - public static Intent intentForDeepLinkMethod81(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink82/{param1}") - public static Intent intentForDeepLinkMethod82(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink83/{param1}") - public static Intent intentForDeepLinkMethod83(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink84/{param1}") - public static Intent intentForDeepLinkMethod84(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink85/{param1}") - public static Intent intentForDeepLinkMethod85(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink86/{param1}") - public static Intent intentForDeepLinkMethod86(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink87/{param1}") - public static Intent intentForDeepLinkMethod87(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink88/{param1}") - public static Intent intentForDeepLinkMethod88(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink89/{param1}") - public static Intent intentForDeepLinkMethod89(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink90/{param1}") - public static Intent intentForDeepLinkMethod90(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink91/{param1}") - public static Intent intentForDeepLinkMethod91(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink92/{param1}") - public static Intent intentForDeepLinkMethod92(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink93/{param1}") - public static Intent intentForDeepLinkMethod93(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink94/{param1}") - public static Intent intentForDeepLinkMethod94(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink95/{param1}") - public static Intent intentForDeepLinkMethod95(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink96/{param1}") - public static Intent intentForDeepLinkMethod96(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink97/{param1}") - public static Intent intentForDeepLinkMethod97(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink98/{param1}") - public static Intent intentForDeepLinkMethod98(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink99/{param1}") - public static Intent intentForDeepLinkMethod99(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink100/{param1}") - public static Intent intentForDeepLinkMethod100(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink101/{param1}") - public static Intent intentForDeepLinkMethod101(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink102/{param1}") - public static Intent intentForDeepLinkMethod102(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink103/{param1}") - public static Intent intentForDeepLinkMethod103(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink104/{param1}") - public static Intent intentForDeepLinkMethod104(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink105/{param1}") - public static Intent intentForDeepLinkMethod105(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink106/{param1}") - public static Intent intentForDeepLinkMethod106(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink107/{param1}") - public static Intent intentForDeepLinkMethod107(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink108/{param1}") - public static Intent intentForDeepLinkMethod108(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink109/{param1}") - public static Intent intentForDeepLinkMethod109(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink110/{param1}") - public static Intent intentForDeepLinkMethod110(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink111/{param1}") - public static Intent intentForDeepLinkMethod111(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink112/{param1}") - public static Intent intentForDeepLinkMethod112(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink113/{param1}") - public static Intent intentForDeepLinkMethod113(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink114/{param1}") - public static Intent intentForDeepLinkMethod114(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink115/{param1}") - public static Intent intentForDeepLinkMethod115(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink116/{param1}") - public static Intent intentForDeepLinkMethod116(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink117/{param1}") - public static Intent intentForDeepLinkMethod117(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink118/{param1}") - public static Intent intentForDeepLinkMethod118(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink119/{param1}") - public static Intent intentForDeepLinkMethod119(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink120/{param1}") - public static Intent intentForDeepLinkMethod120(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink121/{param1}") - public static Intent intentForDeepLinkMethod121(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink122/{param1}") - public static Intent intentForDeepLinkMethod122(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink123/{param1}") - public static Intent intentForDeepLinkMethod123(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink124/{param1}") - public static Intent intentForDeepLinkMethod124(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink125/{param1}") - public static Intent intentForDeepLinkMethod125(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink126/{param1}") - public static Intent intentForDeepLinkMethod126(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink127/{param1}") - public static Intent intentForDeepLinkMethod127(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink128/{param1}") - public static Intent intentForDeepLinkMethod128(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink129/{param1}") - public static Intent intentForDeepLinkMethod129(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink130/{param1}") - public static Intent intentForDeepLinkMethod130(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink131/{param1}") - public static Intent intentForDeepLinkMethod131(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink132/{param1}") - public static Intent intentForDeepLinkMethod132(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink133/{param1}") - public static Intent intentForDeepLinkMethod133(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink134/{param1}") - public static Intent intentForDeepLinkMethod134(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink135/{param1}") - public static Intent intentForDeepLinkMethod135(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink136/{param1}") - public static Intent intentForDeepLinkMethod136(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink137/{param1}") - public static Intent intentForDeepLinkMethod137(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink138/{param1}") - public static Intent intentForDeepLinkMethod138(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink139/{param1}") - public static Intent intentForDeepLinkMethod139(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink140/{param1}") - public static Intent intentForDeepLinkMethod140(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink141/{param1}") - public static Intent intentForDeepLinkMethod141(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink142/{param1}") - public static Intent intentForDeepLinkMethod142(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink143/{param1}") - public static Intent intentForDeepLinkMethod143(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink144/{param1}") - public static Intent intentForDeepLinkMethod144(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink145/{param1}") - public static Intent intentForDeepLinkMethod145(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink146/{param1}") - public static Intent intentForDeepLinkMethod146(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink147/{param1}") - public static Intent intentForDeepLinkMethod147(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink148/{param1}") - public static Intent intentForDeepLinkMethod148(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink149/{param1}") - public static Intent intentForDeepLinkMethod149(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink150/{param1}") - public static Intent intentForDeepLinkMethod150(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink151/{param1}") - public static Intent intentForDeepLinkMethod151(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink152/{param1}") - public static Intent intentForDeepLinkMethod152(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink153/{param1}") - public static Intent intentForDeepLinkMethod153(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink154/{param1}") - public static Intent intentForDeepLinkMethod154(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink155/{param1}") - public static Intent intentForDeepLinkMethod155(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink156/{param1}") - public static Intent intentForDeepLinkMethod156(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink157/{param1}") - public static Intent intentForDeepLinkMethod157(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink158/{param1}") - public static Intent intentForDeepLinkMethod158(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink159/{param1}") - public static Intent intentForDeepLinkMethod159(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink160/{param1}") - public static Intent intentForDeepLinkMethod160(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink161/{param1}") - public static Intent intentForDeepLinkMethod161(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink162/{param1}") - public static Intent intentForDeepLinkMethod162(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink163/{param1}") - public static Intent intentForDeepLinkMethod163(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink164/{param1}") - public static Intent intentForDeepLinkMethod164(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink165/{param1}") - public static Intent intentForDeepLinkMethod165(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink166/{param1}") - public static Intent intentForDeepLinkMethod166(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink167/{param1}") - public static Intent intentForDeepLinkMethod167(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink168/{param1}") - public static Intent intentForDeepLinkMethod168(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink169/{param1}") - public static Intent intentForDeepLinkMethod169(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink170/{param1}") - public static Intent intentForDeepLinkMethod170(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink171/{param1}") - public static Intent intentForDeepLinkMethod171(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink172/{param1}") - public static Intent intentForDeepLinkMethod172(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink173/{param1}") - public static Intent intentForDeepLinkMethod173(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink174/{param1}") - public static Intent intentForDeepLinkMethod174(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink175/{param1}") - public static Intent intentForDeepLinkMethod175(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink176/{param1}") - public static Intent intentForDeepLinkMethod176(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink177/{param1}") - public static Intent intentForDeepLinkMethod177(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink178/{param1}") - public static Intent intentForDeepLinkMethod178(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink179/{param1}") - public static Intent intentForDeepLinkMethod179(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink180/{param1}") - public static Intent intentForDeepLinkMethod180(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink181/{param1}") - public static Intent intentForDeepLinkMethod181(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink182/{param1}") - public static Intent intentForDeepLinkMethod182(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink183/{param1}") - public static Intent intentForDeepLinkMethod183(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink184/{param1}") - public static Intent intentForDeepLinkMethod184(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink185/{param1}") - public static Intent intentForDeepLinkMethod185(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink186/{param1}") - public static Intent intentForDeepLinkMethod186(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink187/{param1}") - public static Intent intentForDeepLinkMethod187(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink188/{param1}") - public static Intent intentForDeepLinkMethod188(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink189/{param1}") - public static Intent intentForDeepLinkMethod189(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink190/{param1}") - public static Intent intentForDeepLinkMethod190(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink191/{param1}") - public static Intent intentForDeepLinkMethod191(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink192/{param1}") - public static Intent intentForDeepLinkMethod192(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink193/{param1}") - public static Intent intentForDeepLinkMethod193(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink194/{param1}") - public static Intent intentForDeepLinkMethod194(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink195/{param1}") - public static Intent intentForDeepLinkMethod195(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink196/{param1}") - public static Intent intentForDeepLinkMethod196(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink197/{param1}") - public static Intent intentForDeepLinkMethod197(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink198/{param1}") - public static Intent intentForDeepLinkMethod198(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink199/{param1}") - public static Intent intentForDeepLinkMethod199(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink200/{param1}") - public static Intent intentForDeepLinkMethod200(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink201/{param1}") - public static Intent intentForDeepLinkMethod201(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink202/{param1}") - public static Intent intentForDeepLinkMethod202(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink203/{param1}") - public static Intent intentForDeepLinkMethod203(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink204/{param1}") - public static Intent intentForDeepLinkMethod204(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink205/{param1}") - public static Intent intentForDeepLinkMethod205(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink206/{param1}") - public static Intent intentForDeepLinkMethod206(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink207/{param1}") - public static Intent intentForDeepLinkMethod207(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink208/{param1}") - public static Intent intentForDeepLinkMethod208(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink209/{param1}") - public static Intent intentForDeepLinkMethod209(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink210/{param1}") - public static Intent intentForDeepLinkMethod210(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink211/{param1}") - public static Intent intentForDeepLinkMethod211(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink212/{param1}") - public static Intent intentForDeepLinkMethod212(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink213/{param1}") - public static Intent intentForDeepLinkMethod213(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink214/{param1}") - public static Intent intentForDeepLinkMethod214(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink215/{param1}") - public static Intent intentForDeepLinkMethod215(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink216/{param1}") - public static Intent intentForDeepLinkMethod216(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink217/{param1}") - public static Intent intentForDeepLinkMethod217(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink218/{param1}") - public static Intent intentForDeepLinkMethod218(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink219/{param1}") - public static Intent intentForDeepLinkMethod219(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink220/{param1}") - public static Intent intentForDeepLinkMethod220(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink221/{param1}") - public static Intent intentForDeepLinkMethod221(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink222/{param1}") - public static Intent intentForDeepLinkMethod222(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink223/{param1}") - public static Intent intentForDeepLinkMethod223(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink224/{param1}") - public static Intent intentForDeepLinkMethod224(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink225/{param1}") - public static Intent intentForDeepLinkMethod225(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink226/{param1}") - public static Intent intentForDeepLinkMethod226(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink227/{param1}") - public static Intent intentForDeepLinkMethod227(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink228/{param1}") - public static Intent intentForDeepLinkMethod228(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink229/{param1}") - public static Intent intentForDeepLinkMethod229(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink230/{param1}") - public static Intent intentForDeepLinkMethod230(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink231/{param1}") - public static Intent intentForDeepLinkMethod231(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink232/{param1}") - public static Intent intentForDeepLinkMethod232(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink233/{param1}") - public static Intent intentForDeepLinkMethod233(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink234/{param1}") - public static Intent intentForDeepLinkMethod234(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink235/{param1}") - public static Intent intentForDeepLinkMethod235(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink236/{param1}") - public static Intent intentForDeepLinkMethod236(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink237/{param1}") - public static Intent intentForDeepLinkMethod237(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink238/{param1}") - public static Intent intentForDeepLinkMethod238(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink239/{param1}") - public static Intent intentForDeepLinkMethod239(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink240/{param1}") - public static Intent intentForDeepLinkMethod240(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink241/{param1}") - public static Intent intentForDeepLinkMethod241(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink242/{param1}") - public static Intent intentForDeepLinkMethod242(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink243/{param1}") - public static Intent intentForDeepLinkMethod243(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink244/{param1}") - public static Intent intentForDeepLinkMethod244(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink245/{param1}") - public static Intent intentForDeepLinkMethod245(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink246/{param1}") - public static Intent intentForDeepLinkMethod246(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink247/{param1}") - public static Intent intentForDeepLinkMethod247(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink248/{param1}") - public static Intent intentForDeepLinkMethod248(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink249/{param1}") - public static Intent intentForDeepLinkMethod249(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink250/{param1}") - public static Intent intentForDeepLinkMethod250(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink251/{param1}") - public static Intent intentForDeepLinkMethod251(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink252/{param1}") - public static Intent intentForDeepLinkMethod252(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink253/{param1}") - public static Intent intentForDeepLinkMethod253(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink254/{param1}") - public static Intent intentForDeepLinkMethod254(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink255/{param1}") - public static Intent intentForDeepLinkMethod255(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink256/{param1}") - public static Intent intentForDeepLinkMethod256(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink257/{param1}") - public static Intent intentForDeepLinkMethod257(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink258/{param1}") - public static Intent intentForDeepLinkMethod258(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink259/{param1}") - public static Intent intentForDeepLinkMethod259(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink260/{param1}") - public static Intent intentForDeepLinkMethod260(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink261/{param1}") - public static Intent intentForDeepLinkMethod261(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink262/{param1}") - public static Intent intentForDeepLinkMethod262(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink263/{param1}") - public static Intent intentForDeepLinkMethod263(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink264/{param1}") - public static Intent intentForDeepLinkMethod264(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink265/{param1}") - public static Intent intentForDeepLinkMethod265(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink266/{param1}") - public static Intent intentForDeepLinkMethod266(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink267/{param1}") - public static Intent intentForDeepLinkMethod267(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink268/{param1}") - public static Intent intentForDeepLinkMethod268(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink269/{param1}") - public static Intent intentForDeepLinkMethod269(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink270/{param1}") - public static Intent intentForDeepLinkMethod270(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink271/{param1}") - public static Intent intentForDeepLinkMethod271(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink272/{param1}") - public static Intent intentForDeepLinkMethod272(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink273/{param1}") - public static Intent intentForDeepLinkMethod273(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink274/{param1}") - public static Intent intentForDeepLinkMethod274(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink275/{param1}") - public static Intent intentForDeepLinkMethod275(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink276/{param1}") - public static Intent intentForDeepLinkMethod276(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink277/{param1}") - public static Intent intentForDeepLinkMethod277(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink278/{param1}") - public static Intent intentForDeepLinkMethod278(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink279/{param1}") - public static Intent intentForDeepLinkMethod279(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink280/{param1}") - public static Intent intentForDeepLinkMethod280(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink281/{param1}") - public static Intent intentForDeepLinkMethod281(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink282/{param1}") - public static Intent intentForDeepLinkMethod282(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink283/{param1}") - public static Intent intentForDeepLinkMethod283(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink284/{param1}") - public static Intent intentForDeepLinkMethod284(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink285/{param1}") - public static Intent intentForDeepLinkMethod285(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink286/{param1}") - public static Intent intentForDeepLinkMethod286(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink287/{param1}") - public static Intent intentForDeepLinkMethod287(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink288/{param1}") - public static Intent intentForDeepLinkMethod288(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink289/{param1}") - public static Intent intentForDeepLinkMethod289(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink290/{param1}") - public static Intent intentForDeepLinkMethod290(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink291/{param1}") - public static Intent intentForDeepLinkMethod291(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink292/{param1}") - public static Intent intentForDeepLinkMethod292(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink293/{param1}") - public static Intent intentForDeepLinkMethod293(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink294/{param1}") - public static Intent intentForDeepLinkMethod294(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink295/{param1}") - public static Intent intentForDeepLinkMethod295(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink296/{param1}") - public static Intent intentForDeepLinkMethod296(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink297/{param1}") - public static Intent intentForDeepLinkMethod297(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink298/{param1}") - public static Intent intentForDeepLinkMethod298(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink299/{param1}") - public static Intent intentForDeepLinkMethod299(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink300/{param1}") - public static Intent intentForDeepLinkMethod300(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink301/{param1}") - public static Intent intentForDeepLinkMethod301(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink302/{param1}") - public static Intent intentForDeepLinkMethod302(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink303/{param1}") - public static Intent intentForDeepLinkMethod303(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink304/{param1}") - public static Intent intentForDeepLinkMethod304(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink305/{param1}") - public static Intent intentForDeepLinkMethod305(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink306/{param1}") - public static Intent intentForDeepLinkMethod306(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink307/{param1}") - public static Intent intentForDeepLinkMethod307(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink308/{param1}") - public static Intent intentForDeepLinkMethod308(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink309/{param1}") - public static Intent intentForDeepLinkMethod309(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink310/{param1}") - public static Intent intentForDeepLinkMethod310(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink311/{param1}") - public static Intent intentForDeepLinkMethod311(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink312/{param1}") - public static Intent intentForDeepLinkMethod312(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink313/{param1}") - public static Intent intentForDeepLinkMethod313(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink314/{param1}") - public static Intent intentForDeepLinkMethod314(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink315/{param1}") - public static Intent intentForDeepLinkMethod315(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink316/{param1}") - public static Intent intentForDeepLinkMethod316(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink317/{param1}") - public static Intent intentForDeepLinkMethod317(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink318/{param1}") - public static Intent intentForDeepLinkMethod318(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink319/{param1}") - public static Intent intentForDeepLinkMethod319(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink320/{param1}") - public static Intent intentForDeepLinkMethod320(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink321/{param1}") - public static Intent intentForDeepLinkMethod321(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink322/{param1}") - public static Intent intentForDeepLinkMethod322(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink323/{param1}") - public static Intent intentForDeepLinkMethod323(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink324/{param1}") - public static Intent intentForDeepLinkMethod324(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink325/{param1}") - public static Intent intentForDeepLinkMethod325(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink326/{param1}") - public static Intent intentForDeepLinkMethod326(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink327/{param1}") - public static Intent intentForDeepLinkMethod327(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink328/{param1}") - public static Intent intentForDeepLinkMethod328(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink329/{param1}") - public static Intent intentForDeepLinkMethod329(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink330/{param1}") - public static Intent intentForDeepLinkMethod330(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink331/{param1}") - public static Intent intentForDeepLinkMethod331(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink332/{param1}") - public static Intent intentForDeepLinkMethod332(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink333/{param1}") - public static Intent intentForDeepLinkMethod333(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink334/{param1}") - public static Intent intentForDeepLinkMethod334(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink335/{param1}") - public static Intent intentForDeepLinkMethod335(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink336/{param1}") - public static Intent intentForDeepLinkMethod336(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink337/{param1}") - public static Intent intentForDeepLinkMethod337(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink338/{param1}") - public static Intent intentForDeepLinkMethod338(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink339/{param1}") - public static Intent intentForDeepLinkMethod339(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink340/{param1}") - public static Intent intentForDeepLinkMethod340(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink341/{param1}") - public static Intent intentForDeepLinkMethod341(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink342/{param1}") - public static Intent intentForDeepLinkMethod342(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink343/{param1}") - public static Intent intentForDeepLinkMethod343(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink344/{param1}") - public static Intent intentForDeepLinkMethod344(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink345/{param1}") - public static Intent intentForDeepLinkMethod345(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink346/{param1}") - public static Intent intentForDeepLinkMethod346(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink347/{param1}") - public static Intent intentForDeepLinkMethod347(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink348/{param1}") - public static Intent intentForDeepLinkMethod348(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink349/{param1}") - public static Intent intentForDeepLinkMethod349(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink350/{param1}") - public static Intent intentForDeepLinkMethod350(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink351/{param1}") - public static Intent intentForDeepLinkMethod351(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink352/{param1}") - public static Intent intentForDeepLinkMethod352(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink353/{param1}") - public static Intent intentForDeepLinkMethod353(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink354/{param1}") - public static Intent intentForDeepLinkMethod354(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink355/{param1}") - public static Intent intentForDeepLinkMethod355(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink356/{param1}") - public static Intent intentForDeepLinkMethod356(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink357/{param1}") - public static Intent intentForDeepLinkMethod357(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink358/{param1}") - public static Intent intentForDeepLinkMethod358(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink359/{param1}") - public static Intent intentForDeepLinkMethod359(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink360/{param1}") - public static Intent intentForDeepLinkMethod360(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink361/{param1}") - public static Intent intentForDeepLinkMethod361(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink362/{param1}") - public static Intent intentForDeepLinkMethod362(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink363/{param1}") - public static Intent intentForDeepLinkMethod363(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink364/{param1}") - public static Intent intentForDeepLinkMethod364(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink365/{param1}") - public static Intent intentForDeepLinkMethod365(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink366/{param1}") - public static Intent intentForDeepLinkMethod366(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink367/{param1}") - public static Intent intentForDeepLinkMethod367(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink368/{param1}") - public static Intent intentForDeepLinkMethod368(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink369/{param1}") - public static Intent intentForDeepLinkMethod369(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink370/{param1}") - public static Intent intentForDeepLinkMethod370(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink371/{param1}") - public static Intent intentForDeepLinkMethod371(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink372/{param1}") - public static Intent intentForDeepLinkMethod372(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink373/{param1}") - public static Intent intentForDeepLinkMethod373(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink374/{param1}") - public static Intent intentForDeepLinkMethod374(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink375/{param1}") - public static Intent intentForDeepLinkMethod375(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink376/{param1}") - public static Intent intentForDeepLinkMethod376(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink377/{param1}") - public static Intent intentForDeepLinkMethod377(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink378/{param1}") - public static Intent intentForDeepLinkMethod378(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink379/{param1}") - public static Intent intentForDeepLinkMethod379(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink380/{param1}") - public static Intent intentForDeepLinkMethod380(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink381/{param1}") - public static Intent intentForDeepLinkMethod381(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink382/{param1}") - public static Intent intentForDeepLinkMethod382(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink383/{param1}") - public static Intent intentForDeepLinkMethod383(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink384/{param1}") - public static Intent intentForDeepLinkMethod384(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink385/{param1}") - public static Intent intentForDeepLinkMethod385(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink386/{param1}") - public static Intent intentForDeepLinkMethod386(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink387/{param1}") - public static Intent intentForDeepLinkMethod387(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink388/{param1}") - public static Intent intentForDeepLinkMethod388(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink389/{param1}") - public static Intent intentForDeepLinkMethod389(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink390/{param1}") - public static Intent intentForDeepLinkMethod390(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink391/{param1}") - public static Intent intentForDeepLinkMethod391(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink392/{param1}") - public static Intent intentForDeepLinkMethod392(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink393/{param1}") - public static Intent intentForDeepLinkMethod393(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink394/{param1}") - public static Intent intentForDeepLinkMethod394(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink395/{param1}") - public static Intent intentForDeepLinkMethod395(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink396/{param1}") - public static Intent intentForDeepLinkMethod396(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink397/{param1}") - public static Intent intentForDeepLinkMethod397(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink398/{param1}") - public static Intent intentForDeepLinkMethod398(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink399/{param1}") - public static Intent intentForDeepLinkMethod399(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink400/{param1}") - public static Intent intentForDeepLinkMethod400(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink401/{param1}") - public static Intent intentForDeepLinkMethod401(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink402/{param1}") - public static Intent intentForDeepLinkMethod402(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink403/{param1}") - public static Intent intentForDeepLinkMethod403(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink404/{param1}") - public static Intent intentForDeepLinkMethod404(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink405/{param1}") - public static Intent intentForDeepLinkMethod405(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink406/{param1}") - public static Intent intentForDeepLinkMethod406(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink407/{param1}") - public static Intent intentForDeepLinkMethod407(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink408/{param1}") - public static Intent intentForDeepLinkMethod408(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink409/{param1}") - public static Intent intentForDeepLinkMethod409(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink410/{param1}") - public static Intent intentForDeepLinkMethod410(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink411/{param1}") - public static Intent intentForDeepLinkMethod411(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink412/{param1}") - public static Intent intentForDeepLinkMethod412(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink413/{param1}") - public static Intent intentForDeepLinkMethod413(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink414/{param1}") - public static Intent intentForDeepLinkMethod414(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink415/{param1}") - public static Intent intentForDeepLinkMethod415(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink416/{param1}") - public static Intent intentForDeepLinkMethod416(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink417/{param1}") - public static Intent intentForDeepLinkMethod417(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink418/{param1}") - public static Intent intentForDeepLinkMethod418(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink419/{param1}") - public static Intent intentForDeepLinkMethod419(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink420/{param1}") - public static Intent intentForDeepLinkMethod420(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink421/{param1}") - public static Intent intentForDeepLinkMethod421(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink422/{param1}") - public static Intent intentForDeepLinkMethod422(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink423/{param1}") - public static Intent intentForDeepLinkMethod423(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink424/{param1}") - public static Intent intentForDeepLinkMethod424(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink425/{param1}") - public static Intent intentForDeepLinkMethod425(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink426/{param1}") - public static Intent intentForDeepLinkMethod426(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink427/{param1}") - public static Intent intentForDeepLinkMethod427(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink428/{param1}") - public static Intent intentForDeepLinkMethod428(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink429/{param1}") - public static Intent intentForDeepLinkMethod429(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink430/{param1}") - public static Intent intentForDeepLinkMethod430(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink431/{param1}") - public static Intent intentForDeepLinkMethod431(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink432/{param1}") - public static Intent intentForDeepLinkMethod432(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink433/{param1}") - public static Intent intentForDeepLinkMethod433(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink434/{param1}") - public static Intent intentForDeepLinkMethod434(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink435/{param1}") - public static Intent intentForDeepLinkMethod435(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink436/{param1}") - public static Intent intentForDeepLinkMethod436(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink437/{param1}") - public static Intent intentForDeepLinkMethod437(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink438/{param1}") - public static Intent intentForDeepLinkMethod438(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink439/{param1}") - public static Intent intentForDeepLinkMethod439(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink440/{param1}") - public static Intent intentForDeepLinkMethod440(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink441/{param1}") - public static Intent intentForDeepLinkMethod441(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink442/{param1}") - public static Intent intentForDeepLinkMethod442(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink443/{param1}") - public static Intent intentForDeepLinkMethod443(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink444/{param1}") - public static Intent intentForDeepLinkMethod444(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink445/{param1}") - public static Intent intentForDeepLinkMethod445(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink446/{param1}") - public static Intent intentForDeepLinkMethod446(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink447/{param1}") - public static Intent intentForDeepLinkMethod447(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink448/{param1}") - public static Intent intentForDeepLinkMethod448(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink449/{param1}") - public static Intent intentForDeepLinkMethod449(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink450/{param1}") - public static Intent intentForDeepLinkMethod450(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink451/{param1}") - public static Intent intentForDeepLinkMethod451(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink452/{param1}") - public static Intent intentForDeepLinkMethod452(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink453/{param1}") - public static Intent intentForDeepLinkMethod453(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink454/{param1}") - public static Intent intentForDeepLinkMethod454(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink455/{param1}") - public static Intent intentForDeepLinkMethod455(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink456/{param1}") - public static Intent intentForDeepLinkMethod456(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink457/{param1}") - public static Intent intentForDeepLinkMethod457(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink458/{param1}") - public static Intent intentForDeepLinkMethod458(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink459/{param1}") - public static Intent intentForDeepLinkMethod459(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink460/{param1}") - public static Intent intentForDeepLinkMethod460(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink461/{param1}") - public static Intent intentForDeepLinkMethod461(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink462/{param1}") - public static Intent intentForDeepLinkMethod462(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink463/{param1}") - public static Intent intentForDeepLinkMethod463(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink464/{param1}") - public static Intent intentForDeepLinkMethod464(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink465/{param1}") - public static Intent intentForDeepLinkMethod465(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink466/{param1}") - public static Intent intentForDeepLinkMethod466(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink467/{param1}") - public static Intent intentForDeepLinkMethod467(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink468/{param1}") - public static Intent intentForDeepLinkMethod468(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink469/{param1}") - public static Intent intentForDeepLinkMethod469(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink470/{param1}") - public static Intent intentForDeepLinkMethod470(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink471/{param1}") - public static Intent intentForDeepLinkMethod471(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink472/{param1}") - public static Intent intentForDeepLinkMethod472(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink473/{param1}") - public static Intent intentForDeepLinkMethod473(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink474/{param1}") - public static Intent intentForDeepLinkMethod474(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink475/{param1}") - public static Intent intentForDeepLinkMethod475(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink476/{param1}") - public static Intent intentForDeepLinkMethod476(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink477/{param1}") - public static Intent intentForDeepLinkMethod477(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink478/{param1}") - public static Intent intentForDeepLinkMethod478(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink479/{param1}") - public static Intent intentForDeepLinkMethod479(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink480/{param1}") - public static Intent intentForDeepLinkMethod480(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink481/{param1}") - public static Intent intentForDeepLinkMethod481(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink482/{param1}") - public static Intent intentForDeepLinkMethod482(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink483/{param1}") - public static Intent intentForDeepLinkMethod483(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink484/{param1}") - public static Intent intentForDeepLinkMethod484(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink485/{param1}") - public static Intent intentForDeepLinkMethod485(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink486/{param1}") - public static Intent intentForDeepLinkMethod486(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink487/{param1}") - public static Intent intentForDeepLinkMethod487(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink488/{param1}") - public static Intent intentForDeepLinkMethod488(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink489/{param1}") - public static Intent intentForDeepLinkMethod489(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink490/{param1}") - public static Intent intentForDeepLinkMethod490(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink491/{param1}") - public static Intent intentForDeepLinkMethod491(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink492/{param1}") - public static Intent intentForDeepLinkMethod492(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink493/{param1}") - public static Intent intentForDeepLinkMethod493(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink494/{param1}") - public static Intent intentForDeepLinkMethod494(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink495/{param1}") - public static Intent intentForDeepLinkMethod495(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink496/{param1}") - public static Intent intentForDeepLinkMethod496(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink497/{param1}") - public static Intent intentForDeepLinkMethod497(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink498/{param1}") - public static Intent intentForDeepLinkMethod498(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink499/{param1}") - public static Intent intentForDeepLinkMethod499(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink500/{param1}") - public static Intent intentForDeepLinkMethod500(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink501/{param1}") - public static Intent intentForDeepLinkMethod501(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink502/{param1}") - public static Intent intentForDeepLinkMethod502(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink503/{param1}") - public static Intent intentForDeepLinkMethod503(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink504/{param1}") - public static Intent intentForDeepLinkMethod504(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink505/{param1}") - public static Intent intentForDeepLinkMethod505(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink506/{param1}") - public static Intent intentForDeepLinkMethod506(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink507/{param1}") - public static Intent intentForDeepLinkMethod507(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink508/{param1}") - public static Intent intentForDeepLinkMethod508(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink509/{param1}") - public static Intent intentForDeepLinkMethod509(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink510/{param1}") - public static Intent intentForDeepLinkMethod510(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink511/{param1}") - public static Intent intentForDeepLinkMethod511(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink512/{param1}") - public static Intent intentForDeepLinkMethod512(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink513/{param1}") - public static Intent intentForDeepLinkMethod513(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink514/{param1}") - public static Intent intentForDeepLinkMethod514(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink515/{param1}") - public static Intent intentForDeepLinkMethod515(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink516/{param1}") - public static Intent intentForDeepLinkMethod516(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink517/{param1}") - public static Intent intentForDeepLinkMethod517(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink518/{param1}") - public static Intent intentForDeepLinkMethod518(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink519/{param1}") - public static Intent intentForDeepLinkMethod519(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink520/{param1}") - public static Intent intentForDeepLinkMethod520(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink521/{param1}") - public static Intent intentForDeepLinkMethod521(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink522/{param1}") - public static Intent intentForDeepLinkMethod522(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink523/{param1}") - public static Intent intentForDeepLinkMethod523(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink524/{param1}") - public static Intent intentForDeepLinkMethod524(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink525/{param1}") - public static Intent intentForDeepLinkMethod525(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink526/{param1}") - public static Intent intentForDeepLinkMethod526(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink527/{param1}") - public static Intent intentForDeepLinkMethod527(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink528/{param1}") - public static Intent intentForDeepLinkMethod528(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink529/{param1}") - public static Intent intentForDeepLinkMethod529(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink530/{param1}") - public static Intent intentForDeepLinkMethod530(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink531/{param1}") - public static Intent intentForDeepLinkMethod531(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink532/{param1}") - public static Intent intentForDeepLinkMethod532(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink533/{param1}") - public static Intent intentForDeepLinkMethod533(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink534/{param1}") - public static Intent intentForDeepLinkMethod534(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink535/{param1}") - public static Intent intentForDeepLinkMethod535(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink536/{param1}") - public static Intent intentForDeepLinkMethod536(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink537/{param1}") - public static Intent intentForDeepLinkMethod537(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink538/{param1}") - public static Intent intentForDeepLinkMethod538(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink539/{param1}") - public static Intent intentForDeepLinkMethod539(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink540/{param1}") - public static Intent intentForDeepLinkMethod540(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink541/{param1}") - public static Intent intentForDeepLinkMethod541(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink542/{param1}") - public static Intent intentForDeepLinkMethod542(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink543/{param1}") - public static Intent intentForDeepLinkMethod543(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink544/{param1}") - public static Intent intentForDeepLinkMethod544(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink545/{param1}") - public static Intent intentForDeepLinkMethod545(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink546/{param1}") - public static Intent intentForDeepLinkMethod546(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink547/{param1}") - public static Intent intentForDeepLinkMethod547(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink548/{param1}") - public static Intent intentForDeepLinkMethod548(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink549/{param1}") - public static Intent intentForDeepLinkMethod549(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink550/{param1}") - public static Intent intentForDeepLinkMethod550(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink551/{param1}") - public static Intent intentForDeepLinkMethod551(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink552/{param1}") - public static Intent intentForDeepLinkMethod552(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink553/{param1}") - public static Intent intentForDeepLinkMethod553(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink554/{param1}") - public static Intent intentForDeepLinkMethod554(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink555/{param1}") - public static Intent intentForDeepLinkMethod555(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink556/{param1}") - public static Intent intentForDeepLinkMethod556(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink557/{param1}") - public static Intent intentForDeepLinkMethod557(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink558/{param1}") - public static Intent intentForDeepLinkMethod558(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink559/{param1}") - public static Intent intentForDeepLinkMethod559(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink560/{param1}") - public static Intent intentForDeepLinkMethod560(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink561/{param1}") - public static Intent intentForDeepLinkMethod561(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink562/{param1}") - public static Intent intentForDeepLinkMethod562(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink563/{param1}") - public static Intent intentForDeepLinkMethod563(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink564/{param1}") - public static Intent intentForDeepLinkMethod564(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink565/{param1}") - public static Intent intentForDeepLinkMethod565(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink566/{param1}") - public static Intent intentForDeepLinkMethod566(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink567/{param1}") - public static Intent intentForDeepLinkMethod567(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink568/{param1}") - public static Intent intentForDeepLinkMethod568(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink569/{param1}") - public static Intent intentForDeepLinkMethod569(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink570/{param1}") - public static Intent intentForDeepLinkMethod570(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink571/{param1}") - public static Intent intentForDeepLinkMethod571(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink572/{param1}") - public static Intent intentForDeepLinkMethod572(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink573/{param1}") - public static Intent intentForDeepLinkMethod573(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink574/{param1}") - public static Intent intentForDeepLinkMethod574(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink575/{param1}") - public static Intent intentForDeepLinkMethod575(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink576/{param1}") - public static Intent intentForDeepLinkMethod576(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink577/{param1}") - public static Intent intentForDeepLinkMethod577(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink578/{param1}") - public static Intent intentForDeepLinkMethod578(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink579/{param1}") - public static Intent intentForDeepLinkMethod579(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink580/{param1}") - public static Intent intentForDeepLinkMethod580(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink581/{param1}") - public static Intent intentForDeepLinkMethod581(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink582/{param1}") - public static Intent intentForDeepLinkMethod582(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink583/{param1}") - public static Intent intentForDeepLinkMethod583(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink584/{param1}") - public static Intent intentForDeepLinkMethod584(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink585/{param1}") - public static Intent intentForDeepLinkMethod585(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink586/{param1}") - public static Intent intentForDeepLinkMethod586(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink587/{param1}") - public static Intent intentForDeepLinkMethod587(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink588/{param1}") - public static Intent intentForDeepLinkMethod588(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink589/{param1}") - public static Intent intentForDeepLinkMethod589(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink590/{param1}") - public static Intent intentForDeepLinkMethod590(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink591/{param1}") - public static Intent intentForDeepLinkMethod591(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink592/{param1}") - public static Intent intentForDeepLinkMethod592(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink593/{param1}") - public static Intent intentForDeepLinkMethod593(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink594/{param1}") - public static Intent intentForDeepLinkMethod594(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink595/{param1}") - public static Intent intentForDeepLinkMethod595(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink596/{param1}") - public static Intent intentForDeepLinkMethod596(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink597/{param1}") - public static Intent intentForDeepLinkMethod597(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink598/{param1}") - public static Intent intentForDeepLinkMethod598(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink599/{param1}") - public static Intent intentForDeepLinkMethod599(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink600/{param1}") - public static Intent intentForDeepLinkMethod600(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink601/{param1}") - public static Intent intentForDeepLinkMethod601(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink602/{param1}") - public static Intent intentForDeepLinkMethod602(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink603/{param1}") - public static Intent intentForDeepLinkMethod603(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink604/{param1}") - public static Intent intentForDeepLinkMethod604(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink605/{param1}") - public static Intent intentForDeepLinkMethod605(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink606/{param1}") - public static Intent intentForDeepLinkMethod606(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink607/{param1}") - public static Intent intentForDeepLinkMethod607(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink608/{param1}") - public static Intent intentForDeepLinkMethod608(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink609/{param1}") - public static Intent intentForDeepLinkMethod609(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink610/{param1}") - public static Intent intentForDeepLinkMethod610(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink611/{param1}") - public static Intent intentForDeepLinkMethod611(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink612/{param1}") - public static Intent intentForDeepLinkMethod612(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink613/{param1}") - public static Intent intentForDeepLinkMethod613(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink614/{param1}") - public static Intent intentForDeepLinkMethod614(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink615/{param1}") - public static Intent intentForDeepLinkMethod615(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink616/{param1}") - public static Intent intentForDeepLinkMethod616(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink617/{param1}") - public static Intent intentForDeepLinkMethod617(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink618/{param1}") - public static Intent intentForDeepLinkMethod618(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink619/{param1}") - public static Intent intentForDeepLinkMethod619(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink620/{param1}") - public static Intent intentForDeepLinkMethod620(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink621/{param1}") - public static Intent intentForDeepLinkMethod621(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink622/{param1}") - public static Intent intentForDeepLinkMethod622(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink623/{param1}") - public static Intent intentForDeepLinkMethod623(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink624/{param1}") - public static Intent intentForDeepLinkMethod624(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink625/{param1}") - public static Intent intentForDeepLinkMethod625(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink626/{param1}") - public static Intent intentForDeepLinkMethod626(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink627/{param1}") - public static Intent intentForDeepLinkMethod627(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink628/{param1}") - public static Intent intentForDeepLinkMethod628(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink629/{param1}") - public static Intent intentForDeepLinkMethod629(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink630/{param1}") - public static Intent intentForDeepLinkMethod630(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink631/{param1}") - public static Intent intentForDeepLinkMethod631(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink632/{param1}") - public static Intent intentForDeepLinkMethod632(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink633/{param1}") - public static Intent intentForDeepLinkMethod633(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink634/{param1}") - public static Intent intentForDeepLinkMethod634(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink635/{param1}") - public static Intent intentForDeepLinkMethod635(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink636/{param1}") - public static Intent intentForDeepLinkMethod636(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink637/{param1}") - public static Intent intentForDeepLinkMethod637(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink638/{param1}") - public static Intent intentForDeepLinkMethod638(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink639/{param1}") - public static Intent intentForDeepLinkMethod639(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink640/{param1}") - public static Intent intentForDeepLinkMethod640(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink641/{param1}") - public static Intent intentForDeepLinkMethod641(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink642/{param1}") - public static Intent intentForDeepLinkMethod642(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink643/{param1}") - public static Intent intentForDeepLinkMethod643(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink644/{param1}") - public static Intent intentForDeepLinkMethod644(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink645/{param1}") - public static Intent intentForDeepLinkMethod645(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink646/{param1}") - public static Intent intentForDeepLinkMethod646(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink647/{param1}") - public static Intent intentForDeepLinkMethod647(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink648/{param1}") - public static Intent intentForDeepLinkMethod648(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink649/{param1}") - public static Intent intentForDeepLinkMethod649(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink650/{param1}") - public static Intent intentForDeepLinkMethod650(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink651/{param1}") - public static Intent intentForDeepLinkMethod651(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink652/{param1}") - public static Intent intentForDeepLinkMethod652(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink653/{param1}") - public static Intent intentForDeepLinkMethod653(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink654/{param1}") - public static Intent intentForDeepLinkMethod654(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink655/{param1}") - public static Intent intentForDeepLinkMethod655(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink656/{param1}") - public static Intent intentForDeepLinkMethod656(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink657/{param1}") - public static Intent intentForDeepLinkMethod657(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink658/{param1}") - public static Intent intentForDeepLinkMethod658(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink659/{param1}") - public static Intent intentForDeepLinkMethod659(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink660/{param1}") - public static Intent intentForDeepLinkMethod660(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink661/{param1}") - public static Intent intentForDeepLinkMethod661(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink662/{param1}") - public static Intent intentForDeepLinkMethod662(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink663/{param1}") - public static Intent intentForDeepLinkMethod663(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink664/{param1}") - public static Intent intentForDeepLinkMethod664(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink665/{param1}") - public static Intent intentForDeepLinkMethod665(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink666/{param1}") - public static Intent intentForDeepLinkMethod666(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink667/{param1}") - public static Intent intentForDeepLinkMethod667(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink668/{param1}") - public static Intent intentForDeepLinkMethod668(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink669/{param1}") - public static Intent intentForDeepLinkMethod669(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink670/{param1}") - public static Intent intentForDeepLinkMethod670(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink671/{param1}") - public static Intent intentForDeepLinkMethod671(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink672/{param1}") - public static Intent intentForDeepLinkMethod672(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink673/{param1}") - public static Intent intentForDeepLinkMethod673(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink674/{param1}") - public static Intent intentForDeepLinkMethod674(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink675/{param1}") - public static Intent intentForDeepLinkMethod675(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink676/{param1}") - public static Intent intentForDeepLinkMethod676(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink677/{param1}") - public static Intent intentForDeepLinkMethod677(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink678/{param1}") - public static Intent intentForDeepLinkMethod678(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink679/{param1}") - public static Intent intentForDeepLinkMethod679(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink680/{param1}") - public static Intent intentForDeepLinkMethod680(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink681/{param1}") - public static Intent intentForDeepLinkMethod681(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink682/{param1}") - public static Intent intentForDeepLinkMethod682(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink683/{param1}") - public static Intent intentForDeepLinkMethod683(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink684/{param1}") - public static Intent intentForDeepLinkMethod684(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink685/{param1}") - public static Intent intentForDeepLinkMethod685(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink686/{param1}") - public static Intent intentForDeepLinkMethod686(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink687/{param1}") - public static Intent intentForDeepLinkMethod687(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink688/{param1}") - public static Intent intentForDeepLinkMethod688(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink689/{param1}") - public static Intent intentForDeepLinkMethod689(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink690/{param1}") - public static Intent intentForDeepLinkMethod690(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink691/{param1}") - public static Intent intentForDeepLinkMethod691(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink692/{param1}") - public static Intent intentForDeepLinkMethod692(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink693/{param1}") - public static Intent intentForDeepLinkMethod693(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink694/{param1}") - public static Intent intentForDeepLinkMethod694(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink695/{param1}") - public static Intent intentForDeepLinkMethod695(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink696/{param1}") - public static Intent intentForDeepLinkMethod696(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink697/{param1}") - public static Intent intentForDeepLinkMethod697(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink698/{param1}") - public static Intent intentForDeepLinkMethod698(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink699/{param1}") - public static Intent intentForDeepLinkMethod699(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink700/{param1}") - public static Intent intentForDeepLinkMethod700(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink701/{param1}") - public static Intent intentForDeepLinkMethod701(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink702/{param1}") - public static Intent intentForDeepLinkMethod702(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink703/{param1}") - public static Intent intentForDeepLinkMethod703(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink704/{param1}") - public static Intent intentForDeepLinkMethod704(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink705/{param1}") - public static Intent intentForDeepLinkMethod705(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink706/{param1}") - public static Intent intentForDeepLinkMethod706(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink707/{param1}") - public static Intent intentForDeepLinkMethod707(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink708/{param1}") - public static Intent intentForDeepLinkMethod708(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink709/{param1}") - public static Intent intentForDeepLinkMethod709(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink710/{param1}") - public static Intent intentForDeepLinkMethod710(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink711/{param1}") - public static Intent intentForDeepLinkMethod711(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink712/{param1}") - public static Intent intentForDeepLinkMethod712(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink713/{param1}") - public static Intent intentForDeepLinkMethod713(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink714/{param1}") - public static Intent intentForDeepLinkMethod714(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink715/{param1}") - public static Intent intentForDeepLinkMethod715(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink716/{param1}") - public static Intent intentForDeepLinkMethod716(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink717/{param1}") - public static Intent intentForDeepLinkMethod717(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink718/{param1}") - public static Intent intentForDeepLinkMethod718(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink719/{param1}") - public static Intent intentForDeepLinkMethod719(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink720/{param1}") - public static Intent intentForDeepLinkMethod720(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink721/{param1}") - public static Intent intentForDeepLinkMethod721(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink722/{param1}") - public static Intent intentForDeepLinkMethod722(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink723/{param1}") - public static Intent intentForDeepLinkMethod723(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink724/{param1}") - public static Intent intentForDeepLinkMethod724(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink725/{param1}") - public static Intent intentForDeepLinkMethod725(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink726/{param1}") - public static Intent intentForDeepLinkMethod726(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink727/{param1}") - public static Intent intentForDeepLinkMethod727(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink728/{param1}") - public static Intent intentForDeepLinkMethod728(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink729/{param1}") - public static Intent intentForDeepLinkMethod729(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink730/{param1}") - public static Intent intentForDeepLinkMethod730(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink731/{param1}") - public static Intent intentForDeepLinkMethod731(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink732/{param1}") - public static Intent intentForDeepLinkMethod732(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink733/{param1}") - public static Intent intentForDeepLinkMethod733(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink734/{param1}") - public static Intent intentForDeepLinkMethod734(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink735/{param1}") - public static Intent intentForDeepLinkMethod735(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink736/{param1}") - public static Intent intentForDeepLinkMethod736(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink737/{param1}") - public static Intent intentForDeepLinkMethod737(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink738/{param1}") - public static Intent intentForDeepLinkMethod738(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink739/{param1}") - public static Intent intentForDeepLinkMethod739(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink740/{param1}") - public static Intent intentForDeepLinkMethod740(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink741/{param1}") - public static Intent intentForDeepLinkMethod741(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink742/{param1}") - public static Intent intentForDeepLinkMethod742(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink743/{param1}") - public static Intent intentForDeepLinkMethod743(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink744/{param1}") - public static Intent intentForDeepLinkMethod744(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink745/{param1}") - public static Intent intentForDeepLinkMethod745(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink746/{param1}") - public static Intent intentForDeepLinkMethod746(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink747/{param1}") - public static Intent intentForDeepLinkMethod747(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink748/{param1}") - public static Intent intentForDeepLinkMethod748(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink749/{param1}") - public static Intent intentForDeepLinkMethod749(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink750/{param1}") - public static Intent intentForDeepLinkMethod750(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink751/{param1}") - public static Intent intentForDeepLinkMethod751(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink752/{param1}") - public static Intent intentForDeepLinkMethod752(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink753/{param1}") - public static Intent intentForDeepLinkMethod753(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink754/{param1}") - public static Intent intentForDeepLinkMethod754(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink755/{param1}") - public static Intent intentForDeepLinkMethod755(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink756/{param1}") - public static Intent intentForDeepLinkMethod756(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink757/{param1}") - public static Intent intentForDeepLinkMethod757(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink758/{param1}") - public static Intent intentForDeepLinkMethod758(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink759/{param1}") - public static Intent intentForDeepLinkMethod759(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink760/{param1}") - public static Intent intentForDeepLinkMethod760(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink761/{param1}") - public static Intent intentForDeepLinkMethod761(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink762/{param1}") - public static Intent intentForDeepLinkMethod762(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink763/{param1}") - public static Intent intentForDeepLinkMethod763(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink764/{param1}") - public static Intent intentForDeepLinkMethod764(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink765/{param1}") - public static Intent intentForDeepLinkMethod765(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink766/{param1}") - public static Intent intentForDeepLinkMethod766(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink767/{param1}") - public static Intent intentForDeepLinkMethod767(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink768/{param1}") - public static Intent intentForDeepLinkMethod768(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink769/{param1}") - public static Intent intentForDeepLinkMethod769(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink770/{param1}") - public static Intent intentForDeepLinkMethod770(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink771/{param1}") - public static Intent intentForDeepLinkMethod771(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink772/{param1}") - public static Intent intentForDeepLinkMethod772(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink773/{param1}") - public static Intent intentForDeepLinkMethod773(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink774/{param1}") - public static Intent intentForDeepLinkMethod774(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink775/{param1}") - public static Intent intentForDeepLinkMethod775(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink776/{param1}") - public static Intent intentForDeepLinkMethod776(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink777/{param1}") - public static Intent intentForDeepLinkMethod777(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink778/{param1}") - public static Intent intentForDeepLinkMethod778(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink779/{param1}") - public static Intent intentForDeepLinkMethod779(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink780/{param1}") - public static Intent intentForDeepLinkMethod780(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink781/{param1}") - public static Intent intentForDeepLinkMethod781(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink782/{param1}") - public static Intent intentForDeepLinkMethod782(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink783/{param1}") - public static Intent intentForDeepLinkMethod783(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink784/{param1}") - public static Intent intentForDeepLinkMethod784(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink785/{param1}") - public static Intent intentForDeepLinkMethod785(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink786/{param1}") - public static Intent intentForDeepLinkMethod786(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink787/{param1}") - public static Intent intentForDeepLinkMethod787(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink788/{param1}") - public static Intent intentForDeepLinkMethod788(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink789/{param1}") - public static Intent intentForDeepLinkMethod789(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink790/{param1}") - public static Intent intentForDeepLinkMethod790(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink791/{param1}") - public static Intent intentForDeepLinkMethod791(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink792/{param1}") - public static Intent intentForDeepLinkMethod792(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink793/{param1}") - public static Intent intentForDeepLinkMethod793(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink794/{param1}") - public static Intent intentForDeepLinkMethod794(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink795/{param1}") - public static Intent intentForDeepLinkMethod795(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink796/{param1}") - public static Intent intentForDeepLinkMethod796(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink797/{param1}") - public static Intent intentForDeepLinkMethod797(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink798/{param1}") - public static Intent intentForDeepLinkMethod798(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink799/{param1}") - public static Intent intentForDeepLinkMethod799(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink800/{param1}") - public static Intent intentForDeepLinkMethod800(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink801/{param1}") - public static Intent intentForDeepLinkMethod801(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink802/{param1}") - public static Intent intentForDeepLinkMethod802(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink803/{param1}") - public static Intent intentForDeepLinkMethod803(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink804/{param1}") - public static Intent intentForDeepLinkMethod804(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink805/{param1}") - public static Intent intentForDeepLinkMethod805(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink806/{param1}") - public static Intent intentForDeepLinkMethod806(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink807/{param1}") - public static Intent intentForDeepLinkMethod807(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink808/{param1}") - public static Intent intentForDeepLinkMethod808(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink809/{param1}") - public static Intent intentForDeepLinkMethod809(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink810/{param1}") - public static Intent intentForDeepLinkMethod810(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink811/{param1}") - public static Intent intentForDeepLinkMethod811(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink812/{param1}") - public static Intent intentForDeepLinkMethod812(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink813/{param1}") - public static Intent intentForDeepLinkMethod813(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink814/{param1}") - public static Intent intentForDeepLinkMethod814(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink815/{param1}") - public static Intent intentForDeepLinkMethod815(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink816/{param1}") - public static Intent intentForDeepLinkMethod816(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink817/{param1}") - public static Intent intentForDeepLinkMethod817(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink818/{param1}") - public static Intent intentForDeepLinkMethod818(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink819/{param1}") - public static Intent intentForDeepLinkMethod819(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink820/{param1}") - public static Intent intentForDeepLinkMethod820(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink821/{param1}") - public static Intent intentForDeepLinkMethod821(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink822/{param1}") - public static Intent intentForDeepLinkMethod822(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink823/{param1}") - public static Intent intentForDeepLinkMethod823(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink824/{param1}") - public static Intent intentForDeepLinkMethod824(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink825/{param1}") - public static Intent intentForDeepLinkMethod825(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink826/{param1}") - public static Intent intentForDeepLinkMethod826(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink827/{param1}") - public static Intent intentForDeepLinkMethod827(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink828/{param1}") - public static Intent intentForDeepLinkMethod828(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink829/{param1}") - public static Intent intentForDeepLinkMethod829(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink830/{param1}") - public static Intent intentForDeepLinkMethod830(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink831/{param1}") - public static Intent intentForDeepLinkMethod831(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink832/{param1}") - public static Intent intentForDeepLinkMethod832(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink833/{param1}") - public static Intent intentForDeepLinkMethod833(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink834/{param1}") - public static Intent intentForDeepLinkMethod834(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink835/{param1}") - public static Intent intentForDeepLinkMethod835(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink836/{param1}") - public static Intent intentForDeepLinkMethod836(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink837/{param1}") - public static Intent intentForDeepLinkMethod837(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink838/{param1}") - public static Intent intentForDeepLinkMethod838(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink839/{param1}") - public static Intent intentForDeepLinkMethod839(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink840/{param1}") - public static Intent intentForDeepLinkMethod840(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink841/{param1}") - public static Intent intentForDeepLinkMethod841(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink842/{param1}") - public static Intent intentForDeepLinkMethod842(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink843/{param1}") - public static Intent intentForDeepLinkMethod843(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink844/{param1}") - public static Intent intentForDeepLinkMethod844(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink845/{param1}") - public static Intent intentForDeepLinkMethod845(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink846/{param1}") - public static Intent intentForDeepLinkMethod846(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink847/{param1}") - public static Intent intentForDeepLinkMethod847(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink848/{param1}") - public static Intent intentForDeepLinkMethod848(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink849/{param1}") - public static Intent intentForDeepLinkMethod849(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink850/{param1}") - public static Intent intentForDeepLinkMethod850(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink851/{param1}") - public static Intent intentForDeepLinkMethod851(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink852/{param1}") - public static Intent intentForDeepLinkMethod852(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink853/{param1}") - public static Intent intentForDeepLinkMethod853(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink854/{param1}") - public static Intent intentForDeepLinkMethod854(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink855/{param1}") - public static Intent intentForDeepLinkMethod855(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink856/{param1}") - public static Intent intentForDeepLinkMethod856(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink857/{param1}") - public static Intent intentForDeepLinkMethod857(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink858/{param1}") - public static Intent intentForDeepLinkMethod858(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink859/{param1}") - public static Intent intentForDeepLinkMethod859(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink860/{param1}") - public static Intent intentForDeepLinkMethod860(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink861/{param1}") - public static Intent intentForDeepLinkMethod861(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink862/{param1}") - public static Intent intentForDeepLinkMethod862(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink863/{param1}") - public static Intent intentForDeepLinkMethod863(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink864/{param1}") - public static Intent intentForDeepLinkMethod864(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink865/{param1}") - public static Intent intentForDeepLinkMethod865(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink866/{param1}") - public static Intent intentForDeepLinkMethod866(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink867/{param1}") - public static Intent intentForDeepLinkMethod867(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink868/{param1}") - public static Intent intentForDeepLinkMethod868(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink869/{param1}") - public static Intent intentForDeepLinkMethod869(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink870/{param1}") - public static Intent intentForDeepLinkMethod870(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink871/{param1}") - public static Intent intentForDeepLinkMethod871(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink872/{param1}") - public static Intent intentForDeepLinkMethod872(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink873/{param1}") - public static Intent intentForDeepLinkMethod873(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink874/{param1}") - public static Intent intentForDeepLinkMethod874(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink875/{param1}") - public static Intent intentForDeepLinkMethod875(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink876/{param1}") - public static Intent intentForDeepLinkMethod876(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink877/{param1}") - public static Intent intentForDeepLinkMethod877(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink878/{param1}") - public static Intent intentForDeepLinkMethod878(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink879/{param1}") - public static Intent intentForDeepLinkMethod879(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink880/{param1}") - public static Intent intentForDeepLinkMethod880(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink881/{param1}") - public static Intent intentForDeepLinkMethod881(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink882/{param1}") - public static Intent intentForDeepLinkMethod882(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink883/{param1}") - public static Intent intentForDeepLinkMethod883(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink884/{param1}") - public static Intent intentForDeepLinkMethod884(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink885/{param1}") - public static Intent intentForDeepLinkMethod885(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink886/{param1}") - public static Intent intentForDeepLinkMethod886(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink887/{param1}") - public static Intent intentForDeepLinkMethod887(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink888/{param1}") - public static Intent intentForDeepLinkMethod888(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink889/{param1}") - public static Intent intentForDeepLinkMethod889(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink890/{param1}") - public static Intent intentForDeepLinkMethod890(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink891/{param1}") - public static Intent intentForDeepLinkMethod891(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink892/{param1}") - public static Intent intentForDeepLinkMethod892(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink893/{param1}") - public static Intent intentForDeepLinkMethod893(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink894/{param1}") - public static Intent intentForDeepLinkMethod894(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink895/{param1}") - public static Intent intentForDeepLinkMethod895(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink896/{param1}") - public static Intent intentForDeepLinkMethod896(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink897/{param1}") - public static Intent intentForDeepLinkMethod897(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink898/{param1}") - public static Intent intentForDeepLinkMethod898(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink899/{param1}") - public static Intent intentForDeepLinkMethod899(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink900/{param1}") - public static Intent intentForDeepLinkMethod900(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink901/{param1}") - public static Intent intentForDeepLinkMethod901(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink902/{param1}") - public static Intent intentForDeepLinkMethod902(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink903/{param1}") - public static Intent intentForDeepLinkMethod903(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink904/{param1}") - public static Intent intentForDeepLinkMethod904(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink905/{param1}") - public static Intent intentForDeepLinkMethod905(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink906/{param1}") - public static Intent intentForDeepLinkMethod906(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink907/{param1}") - public static Intent intentForDeepLinkMethod907(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink908/{param1}") - public static Intent intentForDeepLinkMethod908(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink909/{param1}") - public static Intent intentForDeepLinkMethod909(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink910/{param1}") - public static Intent intentForDeepLinkMethod910(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink911/{param1}") - public static Intent intentForDeepLinkMethod911(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink912/{param1}") - public static Intent intentForDeepLinkMethod912(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink913/{param1}") - public static Intent intentForDeepLinkMethod913(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink914/{param1}") - public static Intent intentForDeepLinkMethod914(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink915/{param1}") - public static Intent intentForDeepLinkMethod915(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink916/{param1}") - public static Intent intentForDeepLinkMethod916(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink917/{param1}") - public static Intent intentForDeepLinkMethod917(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink918/{param1}") - public static Intent intentForDeepLinkMethod918(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink919/{param1}") - public static Intent intentForDeepLinkMethod919(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink920/{param1}") - public static Intent intentForDeepLinkMethod920(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink921/{param1}") - public static Intent intentForDeepLinkMethod921(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink922/{param1}") - public static Intent intentForDeepLinkMethod922(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink923/{param1}") - public static Intent intentForDeepLinkMethod923(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink924/{param1}") - public static Intent intentForDeepLinkMethod924(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink925/{param1}") - public static Intent intentForDeepLinkMethod925(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink926/{param1}") - public static Intent intentForDeepLinkMethod926(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink927/{param1}") - public static Intent intentForDeepLinkMethod927(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink928/{param1}") - public static Intent intentForDeepLinkMethod928(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink929/{param1}") - public static Intent intentForDeepLinkMethod929(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink930/{param1}") - public static Intent intentForDeepLinkMethod930(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink931/{param1}") - public static Intent intentForDeepLinkMethod931(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink932/{param1}") - public static Intent intentForDeepLinkMethod932(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink933/{param1}") - public static Intent intentForDeepLinkMethod933(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink934/{param1}") - public static Intent intentForDeepLinkMethod934(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink935/{param1}") - public static Intent intentForDeepLinkMethod935(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink936/{param1}") - public static Intent intentForDeepLinkMethod936(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink937/{param1}") - public static Intent intentForDeepLinkMethod937(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink938/{param1}") - public static Intent intentForDeepLinkMethod938(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink939/{param1}") - public static Intent intentForDeepLinkMethod939(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink940/{param1}") - public static Intent intentForDeepLinkMethod940(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink941/{param1}") - public static Intent intentForDeepLinkMethod941(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink942/{param1}") - public static Intent intentForDeepLinkMethod942(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink943/{param1}") - public static Intent intentForDeepLinkMethod943(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink944/{param1}") - public static Intent intentForDeepLinkMethod944(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink945/{param1}") - public static Intent intentForDeepLinkMethod945(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink946/{param1}") - public static Intent intentForDeepLinkMethod946(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink947/{param1}") - public static Intent intentForDeepLinkMethod947(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink948/{param1}") - public static Intent intentForDeepLinkMethod948(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink949/{param1}") - public static Intent intentForDeepLinkMethod949(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink950/{param1}") - public static Intent intentForDeepLinkMethod950(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink951/{param1}") - public static Intent intentForDeepLinkMethod951(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink952/{param1}") - public static Intent intentForDeepLinkMethod952(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink953/{param1}") - public static Intent intentForDeepLinkMethod953(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink954/{param1}") - public static Intent intentForDeepLinkMethod954(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink955/{param1}") - public static Intent intentForDeepLinkMethod955(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink956/{param1}") - public static Intent intentForDeepLinkMethod956(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink957/{param1}") - public static Intent intentForDeepLinkMethod957(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink958/{param1}") - public static Intent intentForDeepLinkMethod958(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink959/{param1}") - public static Intent intentForDeepLinkMethod959(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink960/{param1}") - public static Intent intentForDeepLinkMethod960(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink961/{param1}") - public static Intent intentForDeepLinkMethod961(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink962/{param1}") - public static Intent intentForDeepLinkMethod962(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink963/{param1}") - public static Intent intentForDeepLinkMethod963(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink964/{param1}") - public static Intent intentForDeepLinkMethod964(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink965/{param1}") - public static Intent intentForDeepLinkMethod965(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink966/{param1}") - public static Intent intentForDeepLinkMethod966(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink967/{param1}") - public static Intent intentForDeepLinkMethod967(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink968/{param1}") - public static Intent intentForDeepLinkMethod968(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink969/{param1}") - public static Intent intentForDeepLinkMethod969(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink970/{param1}") - public static Intent intentForDeepLinkMethod970(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink971/{param1}") - public static Intent intentForDeepLinkMethod971(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink972/{param1}") - public static Intent intentForDeepLinkMethod972(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink973/{param1}") - public static Intent intentForDeepLinkMethod973(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink974/{param1}") - public static Intent intentForDeepLinkMethod974(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink975/{param1}") - public static Intent intentForDeepLinkMethod975(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink976/{param1}") - public static Intent intentForDeepLinkMethod976(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink977/{param1}") - public static Intent intentForDeepLinkMethod977(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink978/{param1}") - public static Intent intentForDeepLinkMethod978(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink979/{param1}") - public static Intent intentForDeepLinkMethod979(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink980/{param1}") - public static Intent intentForDeepLinkMethod980(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink981/{param1}") - public static Intent intentForDeepLinkMethod981(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink982/{param1}") - public static Intent intentForDeepLinkMethod982(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink983/{param1}") - public static Intent intentForDeepLinkMethod983(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink984/{param1}") - public static Intent intentForDeepLinkMethod984(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink985/{param1}") - public static Intent intentForDeepLinkMethod985(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink986/{param1}") - public static Intent intentForDeepLinkMethod986(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink987/{param1}") - public static Intent intentForDeepLinkMethod987(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink988/{param1}") - public static Intent intentForDeepLinkMethod988(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink989/{param1}") - public static Intent intentForDeepLinkMethod989(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink990/{param1}") - public static Intent intentForDeepLinkMethod990(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink991/{param1}") - public static Intent intentForDeepLinkMethod991(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink992/{param1}") - public static Intent intentForDeepLinkMethod992(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink993/{param1}") - public static Intent intentForDeepLinkMethod993(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink994/{param1}") - public static Intent intentForDeepLinkMethod994(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink995/{param1}") - public static Intent intentForDeepLinkMethod995(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink996/{param1}") - public static Intent intentForDeepLinkMethod996(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink997/{param1}") - public static Intent intentForDeepLinkMethod997(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink998/{param1}") - public static Intent intentForDeepLinkMethod998(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink999/{param1}") - public static Intent intentForDeepLinkMethod999(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1000/{param1}") - public static Intent intentForDeepLinkMethod1000(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1001/{param1}") - public static Intent intentForDeepLinkMethod1001(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1002/{param1}") - public static Intent intentForDeepLinkMethod1002(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1003/{param1}") - public static Intent intentForDeepLinkMethod1003(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1004/{param1}") - public static Intent intentForDeepLinkMethod1004(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1005/{param1}") - public static Intent intentForDeepLinkMethod1005(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1006/{param1}") - public static Intent intentForDeepLinkMethod1006(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1007/{param1}") - public static Intent intentForDeepLinkMethod1007(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1008/{param1}") - public static Intent intentForDeepLinkMethod1008(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1009/{param1}") - public static Intent intentForDeepLinkMethod1009(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1010/{param1}") - public static Intent intentForDeepLinkMethod1010(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1011/{param1}") - public static Intent intentForDeepLinkMethod1011(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1012/{param1}") - public static Intent intentForDeepLinkMethod1012(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1013/{param1}") - public static Intent intentForDeepLinkMethod1013(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1014/{param1}") - public static Intent intentForDeepLinkMethod1014(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1015/{param1}") - public static Intent intentForDeepLinkMethod1015(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1016/{param1}") - public static Intent intentForDeepLinkMethod1016(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1017/{param1}") - public static Intent intentForDeepLinkMethod1017(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1018/{param1}") - public static Intent intentForDeepLinkMethod1018(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1019/{param1}") - public static Intent intentForDeepLinkMethod1019(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1020/{param1}") - public static Intent intentForDeepLinkMethod1020(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1021/{param1}") - public static Intent intentForDeepLinkMethod1021(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1022/{param1}") - public static Intent intentForDeepLinkMethod1022(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1023/{param1}") - public static Intent intentForDeepLinkMethod1023(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1024/{param1}") - public static Intent intentForDeepLinkMethod1024(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1025/{param1}") - public static Intent intentForDeepLinkMethod1025(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1026/{param1}") - public static Intent intentForDeepLinkMethod1026(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1027/{param1}") - public static Intent intentForDeepLinkMethod1027(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1028/{param1}") - public static Intent intentForDeepLinkMethod1028(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1029/{param1}") - public static Intent intentForDeepLinkMethod1029(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1030/{param1}") - public static Intent intentForDeepLinkMethod1030(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1031/{param1}") - public static Intent intentForDeepLinkMethod1031(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1032/{param1}") - public static Intent intentForDeepLinkMethod1032(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1033/{param1}") - public static Intent intentForDeepLinkMethod1033(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1034/{param1}") - public static Intent intentForDeepLinkMethod1034(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1035/{param1}") - public static Intent intentForDeepLinkMethod1035(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1036/{param1}") - public static Intent intentForDeepLinkMethod1036(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1037/{param1}") - public static Intent intentForDeepLinkMethod1037(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1038/{param1}") - public static Intent intentForDeepLinkMethod1038(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1039/{param1}") - public static Intent intentForDeepLinkMethod1039(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1040/{param1}") - public static Intent intentForDeepLinkMethod1040(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1041/{param1}") - public static Intent intentForDeepLinkMethod1041(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1042/{param1}") - public static Intent intentForDeepLinkMethod1042(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1043/{param1}") - public static Intent intentForDeepLinkMethod1043(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1044/{param1}") - public static Intent intentForDeepLinkMethod1044(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1045/{param1}") - public static Intent intentForDeepLinkMethod1045(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1046/{param1}") - public static Intent intentForDeepLinkMethod1046(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1047/{param1}") - public static Intent intentForDeepLinkMethod1047(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1048/{param1}") - public static Intent intentForDeepLinkMethod1048(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1049/{param1}") - public static Intent intentForDeepLinkMethod1049(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1050/{param1}") - public static Intent intentForDeepLinkMethod1050(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1051/{param1}") - public static Intent intentForDeepLinkMethod1051(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1052/{param1}") - public static Intent intentForDeepLinkMethod1052(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1053/{param1}") - public static Intent intentForDeepLinkMethod1053(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1054/{param1}") - public static Intent intentForDeepLinkMethod1054(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1055/{param1}") - public static Intent intentForDeepLinkMethod1055(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1056/{param1}") - public static Intent intentForDeepLinkMethod1056(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1057/{param1}") - public static Intent intentForDeepLinkMethod1057(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1058/{param1}") - public static Intent intentForDeepLinkMethod1058(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1059/{param1}") - public static Intent intentForDeepLinkMethod1059(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1060/{param1}") - public static Intent intentForDeepLinkMethod1060(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1061/{param1}") - public static Intent intentForDeepLinkMethod1061(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1062/{param1}") - public static Intent intentForDeepLinkMethod1062(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1063/{param1}") - public static Intent intentForDeepLinkMethod1063(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1064/{param1}") - public static Intent intentForDeepLinkMethod1064(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1065/{param1}") - public static Intent intentForDeepLinkMethod1065(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1066/{param1}") - public static Intent intentForDeepLinkMethod1066(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1067/{param1}") - public static Intent intentForDeepLinkMethod1067(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1068/{param1}") - public static Intent intentForDeepLinkMethod1068(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1069/{param1}") - public static Intent intentForDeepLinkMethod1069(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1070/{param1}") - public static Intent intentForDeepLinkMethod1070(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1071/{param1}") - public static Intent intentForDeepLinkMethod1071(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1072/{param1}") - public static Intent intentForDeepLinkMethod1072(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1073/{param1}") - public static Intent intentForDeepLinkMethod1073(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1074/{param1}") - public static Intent intentForDeepLinkMethod1074(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1075/{param1}") - public static Intent intentForDeepLinkMethod1075(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1076/{param1}") - public static Intent intentForDeepLinkMethod1076(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1077/{param1}") - public static Intent intentForDeepLinkMethod1077(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1078/{param1}") - public static Intent intentForDeepLinkMethod1078(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1079/{param1}") - public static Intent intentForDeepLinkMethod1079(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1080/{param1}") - public static Intent intentForDeepLinkMethod1080(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1081/{param1}") - public static Intent intentForDeepLinkMethod1081(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1082/{param1}") - public static Intent intentForDeepLinkMethod1082(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1083/{param1}") - public static Intent intentForDeepLinkMethod1083(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1084/{param1}") - public static Intent intentForDeepLinkMethod1084(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1085/{param1}") - public static Intent intentForDeepLinkMethod1085(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1086/{param1}") - public static Intent intentForDeepLinkMethod1086(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1087/{param1}") - public static Intent intentForDeepLinkMethod1087(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1088/{param1}") - public static Intent intentForDeepLinkMethod1088(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1089/{param1}") - public static Intent intentForDeepLinkMethod1089(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1090/{param1}") - public static Intent intentForDeepLinkMethod1090(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1091/{param1}") - public static Intent intentForDeepLinkMethod1091(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1092/{param1}") - public static Intent intentForDeepLinkMethod1092(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1093/{param1}") - public static Intent intentForDeepLinkMethod1093(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1094/{param1}") - public static Intent intentForDeepLinkMethod1094(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1095/{param1}") - public static Intent intentForDeepLinkMethod1095(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1096/{param1}") - public static Intent intentForDeepLinkMethod1096(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1097/{param1}") - public static Intent intentForDeepLinkMethod1097(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1098/{param1}") - public static Intent intentForDeepLinkMethod1098(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1099/{param1}") - public static Intent intentForDeepLinkMethod1099(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1100/{param1}") - public static Intent intentForDeepLinkMethod1100(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1101/{param1}") - public static Intent intentForDeepLinkMethod1101(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1102/{param1}") - public static Intent intentForDeepLinkMethod1102(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1103/{param1}") - public static Intent intentForDeepLinkMethod1103(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1104/{param1}") - public static Intent intentForDeepLinkMethod1104(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1105/{param1}") - public static Intent intentForDeepLinkMethod1105(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1106/{param1}") - public static Intent intentForDeepLinkMethod1106(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1107/{param1}") - public static Intent intentForDeepLinkMethod1107(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1108/{param1}") - public static Intent intentForDeepLinkMethod1108(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1109/{param1}") - public static Intent intentForDeepLinkMethod1109(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1110/{param1}") - public static Intent intentForDeepLinkMethod1110(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1111/{param1}") - public static Intent intentForDeepLinkMethod1111(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1112/{param1}") - public static Intent intentForDeepLinkMethod1112(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1113/{param1}") - public static Intent intentForDeepLinkMethod1113(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1114/{param1}") - public static Intent intentForDeepLinkMethod1114(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1115/{param1}") - public static Intent intentForDeepLinkMethod1115(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1116/{param1}") - public static Intent intentForDeepLinkMethod1116(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1117/{param1}") - public static Intent intentForDeepLinkMethod1117(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1118/{param1}") - public static Intent intentForDeepLinkMethod1118(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1119/{param1}") - public static Intent intentForDeepLinkMethod1119(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1120/{param1}") - public static Intent intentForDeepLinkMethod1120(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1121/{param1}") - public static Intent intentForDeepLinkMethod1121(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1122/{param1}") - public static Intent intentForDeepLinkMethod1122(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1123/{param1}") - public static Intent intentForDeepLinkMethod1123(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1124/{param1}") - public static Intent intentForDeepLinkMethod1124(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1125/{param1}") - public static Intent intentForDeepLinkMethod1125(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1126/{param1}") - public static Intent intentForDeepLinkMethod1126(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1127/{param1}") - public static Intent intentForDeepLinkMethod1127(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1128/{param1}") - public static Intent intentForDeepLinkMethod1128(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1129/{param1}") - public static Intent intentForDeepLinkMethod1129(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1130/{param1}") - public static Intent intentForDeepLinkMethod1130(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1131/{param1}") - public static Intent intentForDeepLinkMethod1131(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1132/{param1}") - public static Intent intentForDeepLinkMethod1132(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1133/{param1}") - public static Intent intentForDeepLinkMethod1133(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1134/{param1}") - public static Intent intentForDeepLinkMethod1134(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1135/{param1}") - public static Intent intentForDeepLinkMethod1135(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1136/{param1}") - public static Intent intentForDeepLinkMethod1136(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1137/{param1}") - public static Intent intentForDeepLinkMethod1137(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1138/{param1}") - public static Intent intentForDeepLinkMethod1138(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1139/{param1}") - public static Intent intentForDeepLinkMethod1139(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1140/{param1}") - public static Intent intentForDeepLinkMethod1140(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1141/{param1}") - public static Intent intentForDeepLinkMethod1141(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1142/{param1}") - public static Intent intentForDeepLinkMethod1142(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1143/{param1}") - public static Intent intentForDeepLinkMethod1143(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1144/{param1}") - public static Intent intentForDeepLinkMethod1144(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1145/{param1}") - public static Intent intentForDeepLinkMethod1145(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1146/{param1}") - public static Intent intentForDeepLinkMethod1146(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1147/{param1}") - public static Intent intentForDeepLinkMethod1147(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1148/{param1}") - public static Intent intentForDeepLinkMethod1148(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1149/{param1}") - public static Intent intentForDeepLinkMethod1149(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1150/{param1}") - public static Intent intentForDeepLinkMethod1150(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1151/{param1}") - public static Intent intentForDeepLinkMethod1151(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1152/{param1}") - public static Intent intentForDeepLinkMethod1152(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1153/{param1}") - public static Intent intentForDeepLinkMethod1153(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1154/{param1}") - public static Intent intentForDeepLinkMethod1154(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1155/{param1}") - public static Intent intentForDeepLinkMethod1155(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1156/{param1}") - public static Intent intentForDeepLinkMethod1156(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1157/{param1}") - public static Intent intentForDeepLinkMethod1157(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1158/{param1}") - public static Intent intentForDeepLinkMethod1158(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1159/{param1}") - public static Intent intentForDeepLinkMethod1159(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1160/{param1}") - public static Intent intentForDeepLinkMethod1160(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1161/{param1}") - public static Intent intentForDeepLinkMethod1161(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1162/{param1}") - public static Intent intentForDeepLinkMethod1162(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1163/{param1}") - public static Intent intentForDeepLinkMethod1163(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1164/{param1}") - public static Intent intentForDeepLinkMethod1164(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1165/{param1}") - public static Intent intentForDeepLinkMethod1165(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1166/{param1}") - public static Intent intentForDeepLinkMethod1166(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1167/{param1}") - public static Intent intentForDeepLinkMethod1167(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1168/{param1}") - public static Intent intentForDeepLinkMethod1168(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1169/{param1}") - public static Intent intentForDeepLinkMethod1169(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1170/{param1}") - public static Intent intentForDeepLinkMethod1170(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1171/{param1}") - public static Intent intentForDeepLinkMethod1171(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1172/{param1}") - public static Intent intentForDeepLinkMethod1172(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1173/{param1}") - public static Intent intentForDeepLinkMethod1173(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1174/{param1}") - public static Intent intentForDeepLinkMethod1174(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1175/{param1}") - public static Intent intentForDeepLinkMethod1175(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1176/{param1}") - public static Intent intentForDeepLinkMethod1176(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1177/{param1}") - public static Intent intentForDeepLinkMethod1177(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1178/{param1}") - public static Intent intentForDeepLinkMethod1178(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1179/{param1}") - public static Intent intentForDeepLinkMethod1179(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1180/{param1}") - public static Intent intentForDeepLinkMethod1180(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1181/{param1}") - public static Intent intentForDeepLinkMethod1181(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1182/{param1}") - public static Intent intentForDeepLinkMethod1182(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1183/{param1}") - public static Intent intentForDeepLinkMethod1183(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1184/{param1}") - public static Intent intentForDeepLinkMethod1184(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1185/{param1}") - public static Intent intentForDeepLinkMethod1185(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1186/{param1}") - public static Intent intentForDeepLinkMethod1186(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1187/{param1}") - public static Intent intentForDeepLinkMethod1187(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1188/{param1}") - public static Intent intentForDeepLinkMethod1188(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1189/{param1}") - public static Intent intentForDeepLinkMethod1189(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1190/{param1}") - public static Intent intentForDeepLinkMethod1190(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1191/{param1}") - public static Intent intentForDeepLinkMethod1191(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1192/{param1}") - public static Intent intentForDeepLinkMethod1192(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1193/{param1}") - public static Intent intentForDeepLinkMethod1193(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1194/{param1}") - public static Intent intentForDeepLinkMethod1194(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1195/{param1}") - public static Intent intentForDeepLinkMethod1195(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1196/{param1}") - public static Intent intentForDeepLinkMethod1196(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1197/{param1}") - public static Intent intentForDeepLinkMethod1197(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1198/{param1}") - public static Intent intentForDeepLinkMethod1198(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1199/{param1}") - public static Intent intentForDeepLinkMethod1199(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1200/{param1}") - public static Intent intentForDeepLinkMethod1200(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1201/{param1}") - public static Intent intentForDeepLinkMethod1201(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1202/{param1}") - public static Intent intentForDeepLinkMethod1202(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1203/{param1}") - public static Intent intentForDeepLinkMethod1203(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1204/{param1}") - public static Intent intentForDeepLinkMethod1204(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1205/{param1}") - public static Intent intentForDeepLinkMethod1205(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1206/{param1}") - public static Intent intentForDeepLinkMethod1206(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1207/{param1}") - public static Intent intentForDeepLinkMethod1207(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1208/{param1}") - public static Intent intentForDeepLinkMethod1208(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1209/{param1}") - public static Intent intentForDeepLinkMethod1209(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1210/{param1}") - public static Intent intentForDeepLinkMethod1210(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1211/{param1}") - public static Intent intentForDeepLinkMethod1211(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1212/{param1}") - public static Intent intentForDeepLinkMethod1212(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1213/{param1}") - public static Intent intentForDeepLinkMethod1213(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1214/{param1}") - public static Intent intentForDeepLinkMethod1214(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1215/{param1}") - public static Intent intentForDeepLinkMethod1215(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1216/{param1}") - public static Intent intentForDeepLinkMethod1216(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1217/{param1}") - public static Intent intentForDeepLinkMethod1217(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1218/{param1}") - public static Intent intentForDeepLinkMethod1218(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1219/{param1}") - public static Intent intentForDeepLinkMethod1219(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1220/{param1}") - public static Intent intentForDeepLinkMethod1220(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1221/{param1}") - public static Intent intentForDeepLinkMethod1221(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1222/{param1}") - public static Intent intentForDeepLinkMethod1222(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1223/{param1}") - public static Intent intentForDeepLinkMethod1223(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1224/{param1}") - public static Intent intentForDeepLinkMethod1224(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1225/{param1}") - public static Intent intentForDeepLinkMethod1225(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1226/{param1}") - public static Intent intentForDeepLinkMethod1226(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1227/{param1}") - public static Intent intentForDeepLinkMethod1227(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1228/{param1}") - public static Intent intentForDeepLinkMethod1228(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1229/{param1}") - public static Intent intentForDeepLinkMethod1229(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1230/{param1}") - public static Intent intentForDeepLinkMethod1230(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1231/{param1}") - public static Intent intentForDeepLinkMethod1231(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1232/{param1}") - public static Intent intentForDeepLinkMethod1232(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1233/{param1}") - public static Intent intentForDeepLinkMethod1233(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1234/{param1}") - public static Intent intentForDeepLinkMethod1234(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1235/{param1}") - public static Intent intentForDeepLinkMethod1235(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1236/{param1}") - public static Intent intentForDeepLinkMethod1236(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1237/{param1}") - public static Intent intentForDeepLinkMethod1237(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1238/{param1}") - public static Intent intentForDeepLinkMethod1238(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1239/{param1}") - public static Intent intentForDeepLinkMethod1239(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1240/{param1}") - public static Intent intentForDeepLinkMethod1240(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1241/{param1}") - public static Intent intentForDeepLinkMethod1241(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1242/{param1}") - public static Intent intentForDeepLinkMethod1242(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1243/{param1}") - public static Intent intentForDeepLinkMethod1243(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1244/{param1}") - public static Intent intentForDeepLinkMethod1244(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1245/{param1}") - public static Intent intentForDeepLinkMethod1245(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1246/{param1}") - public static Intent intentForDeepLinkMethod1246(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1247/{param1}") - public static Intent intentForDeepLinkMethod1247(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1248/{param1}") - public static Intent intentForDeepLinkMethod1248(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1249/{param1}") - public static Intent intentForDeepLinkMethod1249(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1250/{param1}") - public static Intent intentForDeepLinkMethod1250(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1251/{param1}") - public static Intent intentForDeepLinkMethod1251(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1252/{param1}") - public static Intent intentForDeepLinkMethod1252(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1253/{param1}") - public static Intent intentForDeepLinkMethod1253(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1254/{param1}") - public static Intent intentForDeepLinkMethod1254(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1255/{param1}") - public static Intent intentForDeepLinkMethod1255(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1256/{param1}") - public static Intent intentForDeepLinkMethod1256(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1257/{param1}") - public static Intent intentForDeepLinkMethod1257(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1258/{param1}") - public static Intent intentForDeepLinkMethod1258(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1259/{param1}") - public static Intent intentForDeepLinkMethod1259(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1260/{param1}") - public static Intent intentForDeepLinkMethod1260(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1261/{param1}") - public static Intent intentForDeepLinkMethod1261(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1262/{param1}") - public static Intent intentForDeepLinkMethod1262(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1263/{param1}") - public static Intent intentForDeepLinkMethod1263(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1264/{param1}") - public static Intent intentForDeepLinkMethod1264(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1265/{param1}") - public static Intent intentForDeepLinkMethod1265(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1266/{param1}") - public static Intent intentForDeepLinkMethod1266(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1267/{param1}") - public static Intent intentForDeepLinkMethod1267(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1268/{param1}") - public static Intent intentForDeepLinkMethod1268(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1269/{param1}") - public static Intent intentForDeepLinkMethod1269(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1270/{param1}") - public static Intent intentForDeepLinkMethod1270(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1271/{param1}") - public static Intent intentForDeepLinkMethod1271(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1272/{param1}") - public static Intent intentForDeepLinkMethod1272(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1273/{param1}") - public static Intent intentForDeepLinkMethod1273(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1274/{param1}") - public static Intent intentForDeepLinkMethod1274(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1275/{param1}") - public static Intent intentForDeepLinkMethod1275(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1276/{param1}") - public static Intent intentForDeepLinkMethod1276(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1277/{param1}") - public static Intent intentForDeepLinkMethod1277(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1278/{param1}") - public static Intent intentForDeepLinkMethod1278(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1279/{param1}") - public static Intent intentForDeepLinkMethod1279(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1280/{param1}") - public static Intent intentForDeepLinkMethod1280(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1281/{param1}") - public static Intent intentForDeepLinkMethod1281(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1282/{param1}") - public static Intent intentForDeepLinkMethod1282(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1283/{param1}") - public static Intent intentForDeepLinkMethod1283(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1284/{param1}") - public static Intent intentForDeepLinkMethod1284(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1285/{param1}") - public static Intent intentForDeepLinkMethod1285(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1286/{param1}") - public static Intent intentForDeepLinkMethod1286(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1287/{param1}") - public static Intent intentForDeepLinkMethod1287(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1288/{param1}") - public static Intent intentForDeepLinkMethod1288(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1289/{param1}") - public static Intent intentForDeepLinkMethod1289(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1290/{param1}") - public static Intent intentForDeepLinkMethod1290(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - @DeepLink("dld://methodDeepLink1291/{param1}") - public static Intent intentForDeepLinkMethod1291(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1292/{param1}") - public static Intent intentForDeepLinkMethod1292(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1293/{param1}") - public static Intent intentForDeepLinkMethod1293(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1294/{param1}") - public static Intent intentForDeepLinkMethod1294(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1295/{param1}") - public static Intent intentForDeepLinkMethod1295(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1296/{param1}") - public static Intent intentForDeepLinkMethod1296(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1297/{param1}") - public static Intent intentForDeepLinkMethod1297(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1298/{param1}") - public static Intent intentForDeepLinkMethod1298(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1299/{param1}") - public static Intent intentForDeepLinkMethod1299(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1300/{param1}") - public static Intent intentForDeepLinkMethod1300(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1301/{param1}") - public static Intent intentForDeepLinkMethod1301(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1302/{param1}") - public static Intent intentForDeepLinkMethod1302(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1303/{param1}") - public static Intent intentForDeepLinkMethod1303(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1304/{param1}") - public static Intent intentForDeepLinkMethod1304(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1305/{param1}") - public static Intent intentForDeepLinkMethod1305(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1306/{param1}") - public static Intent intentForDeepLinkMethod1306(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1307/{param1}") - public static Intent intentForDeepLinkMethod1307(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1308/{param1}") - public static Intent intentForDeepLinkMethod1308(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1309/{param1}") - public static Intent intentForDeepLinkMethod1309(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1310/{param1}") - public static Intent intentForDeepLinkMethod1310(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1311/{param1}") - public static Intent intentForDeepLinkMethod1311(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1312/{param1}") - public static Intent intentForDeepLinkMethod1312(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1313/{param1}") - public static Intent intentForDeepLinkMethod1313(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1314/{param1}") - public static Intent intentForDeepLinkMethod1314(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1315/{param1}") - public static Intent intentForDeepLinkMethod1315(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1316/{param1}") - public static Intent intentForDeepLinkMethod1316(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1317/{param1}") - public static Intent intentForDeepLinkMethod1317(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1318/{param1}") - public static Intent intentForDeepLinkMethod1318(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1319/{param1}") - public static Intent intentForDeepLinkMethod1319(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1320/{param1}") - public static Intent intentForDeepLinkMethod1320(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1321/{param1}") - public static Intent intentForDeepLinkMethod1321(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1322/{param1}") - public static Intent intentForDeepLinkMethod1322(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1323/{param1}") - public static Intent intentForDeepLinkMethod1323(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1324/{param1}") - public static Intent intentForDeepLinkMethod1324(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1325/{param1}") - public static Intent intentForDeepLinkMethod1325(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1326/{param1}") - public static Intent intentForDeepLinkMethod1326(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1327/{param1}") - public static Intent intentForDeepLinkMethod1327(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1328/{param1}") - public static Intent intentForDeepLinkMethod1328(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1329/{param1}") - public static Intent intentForDeepLinkMethod1329(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1330/{param1}") - public static Intent intentForDeepLinkMethod1330(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1331/{param1}") - public static Intent intentForDeepLinkMethod1331(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1332/{param1}") - public static Intent intentForDeepLinkMethod1332(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1333/{param1}") - public static Intent intentForDeepLinkMethod1333(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1334/{param1}") - public static Intent intentForDeepLinkMethod1334(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1335/{param1}") - public static Intent intentForDeepLinkMethod1335(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1336/{param1}") - public static Intent intentForDeepLinkMethod1336(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1337/{param1}") - public static Intent intentForDeepLinkMethod1337(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1338/{param1}") - public static Intent intentForDeepLinkMethod1338(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1339/{param1}") - public static Intent intentForDeepLinkMethod1339(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1340/{param1}") - public static Intent intentForDeepLinkMethod1340(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1341/{param1}") - public static Intent intentForDeepLinkMethod1341(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1342/{param1}") - public static Intent intentForDeepLinkMethod1342(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1343/{param1}") - public static Intent intentForDeepLinkMethod1343(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1344/{param1}") - public static Intent intentForDeepLinkMethod1344(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1345/{param1}") - public static Intent intentForDeepLinkMethod1345(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1346/{param1}") - public static Intent intentForDeepLinkMethod1346(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1347/{param1}") - public static Intent intentForDeepLinkMethod1347(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1348/{param1}") - public static Intent intentForDeepLinkMethod1348(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1349/{param1}") - public static Intent intentForDeepLinkMethod1349(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1350/{param1}") - public static Intent intentForDeepLinkMethod1350(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1351/{param1}") - public static Intent intentForDeepLinkMethod1351(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1352/{param1}") - public static Intent intentForDeepLinkMethod1352(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1353/{param1}") - public static Intent intentForDeepLinkMethod1353(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1354/{param1}") - public static Intent intentForDeepLinkMethod1354(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1355/{param1}") - public static Intent intentForDeepLinkMethod1355(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1356/{param1}") - public static Intent intentForDeepLinkMethod1356(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1357/{param1}") - public static Intent intentForDeepLinkMethod1357(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1358/{param1}") - public static Intent intentForDeepLinkMethod1358(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1359/{param1}") - public static Intent intentForDeepLinkMethod1359(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1360/{param1}") - public static Intent intentForDeepLinkMethod1360(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1361/{param1}") - public static Intent intentForDeepLinkMethod1361(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1362/{param1}") - public static Intent intentForDeepLinkMethod1362(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1363/{param1}") - public static Intent intentForDeepLinkMethod1363(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1364/{param1}") - public static Intent intentForDeepLinkMethod1364(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1365/{param1}") - public static Intent intentForDeepLinkMethod1365(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1366/{param1}") - public static Intent intentForDeepLinkMethod1366(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1367/{param1}") - public static Intent intentForDeepLinkMethod1367(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1368/{param1}") - public static Intent intentForDeepLinkMethod1368(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1369/{param1}") - public static Intent intentForDeepLinkMethod1369(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1370/{param1}") - public static Intent intentForDeepLinkMethod1370(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1371/{param1}") - public static Intent intentForDeepLinkMethod1371(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1372/{param1}") - public static Intent intentForDeepLinkMethod1372(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1373/{param1}") - public static Intent intentForDeepLinkMethod1373(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1374/{param1}") - public static Intent intentForDeepLinkMethod1374(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1375/{param1}") - public static Intent intentForDeepLinkMethod1375(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1376/{param1}") - public static Intent intentForDeepLinkMethod1376(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1377/{param1}") - public static Intent intentForDeepLinkMethod1377(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1378/{param1}") - public static Intent intentForDeepLinkMethod1378(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1379/{param1}") - public static Intent intentForDeepLinkMethod1379(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1380/{param1}") - public static Intent intentForDeepLinkMethod1380(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1381/{param1}") - public static Intent intentForDeepLinkMethod1381(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1382/{param1}") - public static Intent intentForDeepLinkMethod1382(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1383/{param1}") - public static Intent intentForDeepLinkMethod1383(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1384/{param1}") - public static Intent intentForDeepLinkMethod1384(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1385/{param1}") - public static Intent intentForDeepLinkMethod1385(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1386/{param1}") - public static Intent intentForDeepLinkMethod1386(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1387/{param1}") - public static Intent intentForDeepLinkMethod1387(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1388/{param1}") - public static Intent intentForDeepLinkMethod1388(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1389/{param1}") - public static Intent intentForDeepLinkMethod1389(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1390/{param1}") - public static Intent intentForDeepLinkMethod1390(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1391/{param1}") - public static Intent intentForDeepLinkMethod1391(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1392/{param1}") - public static Intent intentForDeepLinkMethod1392(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1393/{param1}") - public static Intent intentForDeepLinkMethod1393(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1394/{param1}") - public static Intent intentForDeepLinkMethod1394(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1395/{param1}") - public static Intent intentForDeepLinkMethod1395(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1396/{param1}") - public static Intent intentForDeepLinkMethod1396(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1397/{param1}") - public static Intent intentForDeepLinkMethod1397(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1398/{param1}") - public static Intent intentForDeepLinkMethod1398(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1399/{param1}") - public static Intent intentForDeepLinkMethod1399(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1400/{param1}") - public static Intent intentForDeepLinkMethod1400(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1401/{param1}") - public static Intent intentForDeepLinkMethod1401(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1402/{param1}") - public static Intent intentForDeepLinkMethod1402(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1403/{param1}") - public static Intent intentForDeepLinkMethod1403(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1404/{param1}") - public static Intent intentForDeepLinkMethod1404(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1405/{param1}") - public static Intent intentForDeepLinkMethod1405(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1406/{param1}") - public static Intent intentForDeepLinkMethod1406(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1407/{param1}") - public static Intent intentForDeepLinkMethod1407(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1408/{param1}") - public static Intent intentForDeepLinkMethod1408(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1409/{param1}") - public static Intent intentForDeepLinkMethod1409(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1410/{param1}") - public static Intent intentForDeepLinkMethod1410(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1411/{param1}") - public static Intent intentForDeepLinkMethod1411(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1412/{param1}") - public static Intent intentForDeepLinkMethod1412(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1413/{param1}") - public static Intent intentForDeepLinkMethod1413(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1414/{param1}") - public static Intent intentForDeepLinkMethod1414(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1415/{param1}") - public static Intent intentForDeepLinkMethod1415(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1416/{param1}") - public static Intent intentForDeepLinkMethod1416(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1417/{param1}") - public static Intent intentForDeepLinkMethod1417(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1418/{param1}") - public static Intent intentForDeepLinkMethod1418(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1419/{param1}") - public static Intent intentForDeepLinkMethod1419(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1420/{param1}") - public static Intent intentForDeepLinkMethod1420(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1421/{param1}") - public static Intent intentForDeepLinkMethod1421(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1422/{param1}") - public static Intent intentForDeepLinkMethod1422(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1423/{param1}") - public static Intent intentForDeepLinkMethod1423(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1424/{param1}") - public static Intent intentForDeepLinkMethod1424(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1425/{param1}") - public static Intent intentForDeepLinkMethod1425(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1426/{param1}") - public static Intent intentForDeepLinkMethod1426(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1427/{param1}") - public static Intent intentForDeepLinkMethod1427(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1428/{param1}") - public static Intent intentForDeepLinkMethod1428(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1429/{param1}") - public static Intent intentForDeepLinkMethod1429(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1430/{param1}") - public static Intent intentForDeepLinkMethod1430(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1431/{param1}") - public static Intent intentForDeepLinkMethod1431(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1432/{param1}") - public static Intent intentForDeepLinkMethod1432(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1433/{param1}") - public static Intent intentForDeepLinkMethod1433(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1434/{param1}") - public static Intent intentForDeepLinkMethod1434(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1435/{param1}") - public static Intent intentForDeepLinkMethod1435(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1436/{param1}") - public static Intent intentForDeepLinkMethod1436(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1437/{param1}") - public static Intent intentForDeepLinkMethod1437(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1438/{param1}") - public static Intent intentForDeepLinkMethod1438(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1439/{param1}") - public static Intent intentForDeepLinkMethod1439(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1440/{param1}") - public static Intent intentForDeepLinkMethod1440(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1441/{param1}") - public static Intent intentForDeepLinkMethod1441(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1442/{param1}") - public static Intent intentForDeepLinkMethod1442(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1443/{param1}") - public static Intent intentForDeepLinkMethod1443(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1444/{param1}") - public static Intent intentForDeepLinkMethod1444(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1445/{param1}") - public static Intent intentForDeepLinkMethod1445(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1446/{param1}") - public static Intent intentForDeepLinkMethod1446(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1447/{param1}") - public static Intent intentForDeepLinkMethod1447(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1448/{param1}") - public static Intent intentForDeepLinkMethod1448(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1449/{param1}") - public static Intent intentForDeepLinkMethod1449(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1450/{param1}") - public static Intent intentForDeepLinkMethod1450(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1451/{param1}") - public static Intent intentForDeepLinkMethod1451(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1452/{param1}") - public static Intent intentForDeepLinkMethod1452(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1453/{param1}") - public static Intent intentForDeepLinkMethod1453(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1454/{param1}") - public static Intent intentForDeepLinkMethod1454(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1455/{param1}") - public static Intent intentForDeepLinkMethod1455(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1456/{param1}") - public static Intent intentForDeepLinkMethod1456(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1457/{param1}") - public static Intent intentForDeepLinkMethod1457(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1458/{param1}") - public static Intent intentForDeepLinkMethod1458(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1459/{param1}") - public static Intent intentForDeepLinkMethod1459(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1460/{param1}") - public static Intent intentForDeepLinkMethod1460(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1461/{param1}") - public static Intent intentForDeepLinkMethod1461(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1462/{param1}") - public static Intent intentForDeepLinkMethod1462(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1463/{param1}") - public static Intent intentForDeepLinkMethod1463(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1464/{param1}") - public static Intent intentForDeepLinkMethod1464(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1465/{param1}") - public static Intent intentForDeepLinkMethod1465(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1466/{param1}") - public static Intent intentForDeepLinkMethod1466(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1467/{param1}") - public static Intent intentForDeepLinkMethod1467(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1468/{param1}") - public static Intent intentForDeepLinkMethod1468(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1469/{param1}") - public static Intent intentForDeepLinkMethod1469(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1470/{param1}") - public static Intent intentForDeepLinkMethod1470(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1471/{param1}") - public static Intent intentForDeepLinkMethod1471(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1472/{param1}") - public static Intent intentForDeepLinkMethod1472(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1473/{param1}") - public static Intent intentForDeepLinkMethod1473(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1474/{param1}") - public static Intent intentForDeepLinkMethod1474(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1475/{param1}") - public static Intent intentForDeepLinkMethod1475(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1476/{param1}") - public static Intent intentForDeepLinkMethod1476(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1477/{param1}") - public static Intent intentForDeepLinkMethod1477(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1478/{param1}") - public static Intent intentForDeepLinkMethod1478(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1479/{param1}") - public static Intent intentForDeepLinkMethod1479(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1480/{param1}") - public static Intent intentForDeepLinkMethod1480(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1481/{param1}") - public static Intent intentForDeepLinkMethod1481(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1482/{param1}") - public static Intent intentForDeepLinkMethod1482(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1483/{param1}") - public static Intent intentForDeepLinkMethod1483(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1484/{param1}") - public static Intent intentForDeepLinkMethod1484(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1485/{param1}") - public static Intent intentForDeepLinkMethod1485(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1486/{param1}") - public static Intent intentForDeepLinkMethod1486(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1487/{param1}") - public static Intent intentForDeepLinkMethod1487(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1488/{param1}") - public static Intent intentForDeepLinkMethod1488(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1489/{param1}") - public static Intent intentForDeepLinkMethod1489(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1490/{param1}") - public static Intent intentForDeepLinkMethod1490(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1491/{param1}") - public static Intent intentForDeepLinkMethod1491(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1492/{param1}") - public static Intent intentForDeepLinkMethod1492(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1493/{param1}") - public static Intent intentForDeepLinkMethod1493(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1494/{param1}") - public static Intent intentForDeepLinkMethod1494(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1495/{param1}") - public static Intent intentForDeepLinkMethod1495(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1496/{param1}") - public static Intent intentForDeepLinkMethod1496(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1497/{param1}") - public static Intent intentForDeepLinkMethod1497(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1498/{param1}") - public static Intent intentForDeepLinkMethod1498(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1499/{param1}") - public static Intent intentForDeepLinkMethod1499(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1500/{param1}") - public static Intent intentForDeepLinkMethod1500(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1501/{param1}") - public static Intent intentForDeepLinkMethod1501(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1502/{param1}") - public static Intent intentForDeepLinkMethod1502(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1503/{param1}") - public static Intent intentForDeepLinkMethod1503(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1504/{param1}") - public static Intent intentForDeepLinkMethod1504(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1505/{param1}") - public static Intent intentForDeepLinkMethod1505(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1506/{param1}") - public static Intent intentForDeepLinkMethod1506(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1507/{param1}") - public static Intent intentForDeepLinkMethod1507(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1508/{param1}") - public static Intent intentForDeepLinkMethod1508(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1509/{param1}") - public static Intent intentForDeepLinkMethod1509(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1510/{param1}") - public static Intent intentForDeepLinkMethod1510(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1511/{param1}") - public static Intent intentForDeepLinkMethod1511(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1512/{param1}") - public static Intent intentForDeepLinkMethod1512(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1513/{param1}") - public static Intent intentForDeepLinkMethod1513(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1514/{param1}") - public static Intent intentForDeepLinkMethod1514(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1515/{param1}") - public static Intent intentForDeepLinkMethod1515(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1516/{param1}") - public static Intent intentForDeepLinkMethod1516(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1517/{param1}") - public static Intent intentForDeepLinkMethod1517(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1518/{param1}") - public static Intent intentForDeepLinkMethod1518(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1519/{param1}") - public static Intent intentForDeepLinkMethod1519(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1520/{param1}") - public static Intent intentForDeepLinkMethod1520(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1521/{param1}") - public static Intent intentForDeepLinkMethod1521(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1522/{param1}") - public static Intent intentForDeepLinkMethod1522(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1523/{param1}") - public static Intent intentForDeepLinkMethod1523(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1524/{param1}") - public static Intent intentForDeepLinkMethod1524(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1525/{param1}") - public static Intent intentForDeepLinkMethod1525(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1526/{param1}") - public static Intent intentForDeepLinkMethod1526(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1527/{param1}") - public static Intent intentForDeepLinkMethod1527(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1528/{param1}") - public static Intent intentForDeepLinkMethod1528(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1529/{param1}") - public static Intent intentForDeepLinkMethod1529(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1530/{param1}") - public static Intent intentForDeepLinkMethod1530(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1531/{param1}") - public static Intent intentForDeepLinkMethod1531(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1532/{param1}") - public static Intent intentForDeepLinkMethod1532(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1533/{param1}") - public static Intent intentForDeepLinkMethod1533(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1534/{param1}") - public static Intent intentForDeepLinkMethod1534(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1535/{param1}") - public static Intent intentForDeepLinkMethod1535(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1536/{param1}") - public static Intent intentForDeepLinkMethod1536(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1537/{param1}") - public static Intent intentForDeepLinkMethod1537(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1538/{param1}") - public static Intent intentForDeepLinkMethod1538(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1539/{param1}") - public static Intent intentForDeepLinkMethod1539(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1540/{param1}") - public static Intent intentForDeepLinkMethod1540(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1541/{param1}") - public static Intent intentForDeepLinkMethod1541(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1542/{param1}") - public static Intent intentForDeepLinkMethod1542(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1543/{param1}") - public static Intent intentForDeepLinkMethod1543(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1544/{param1}") - public static Intent intentForDeepLinkMethod1544(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1545/{param1}") - public static Intent intentForDeepLinkMethod1545(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1546/{param1}") - public static Intent intentForDeepLinkMethod1546(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1547/{param1}") - public static Intent intentForDeepLinkMethod1547(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1548/{param1}") - public static Intent intentForDeepLinkMethod1548(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1549/{param1}") - public static Intent intentForDeepLinkMethod1549(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1550/{param1}") - public static Intent intentForDeepLinkMethod1550(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1551/{param1}") - public static Intent intentForDeepLinkMethod1551(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1552/{param1}") - public static Intent intentForDeepLinkMethod1552(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1553/{param1}") - public static Intent intentForDeepLinkMethod1553(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1554/{param1}") - public static Intent intentForDeepLinkMethod1554(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1555/{param1}") - public static Intent intentForDeepLinkMethod1555(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1556/{param1}") - public static Intent intentForDeepLinkMethod1556(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1557/{param1}") - public static Intent intentForDeepLinkMethod1557(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1558/{param1}") - public static Intent intentForDeepLinkMethod1558(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1559/{param1}") - public static Intent intentForDeepLinkMethod1559(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1560/{param1}") - public static Intent intentForDeepLinkMethod1560(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1561/{param1}") - public static Intent intentForDeepLinkMethod1561(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1562/{param1}") - public static Intent intentForDeepLinkMethod1562(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1563/{param1}") - public static Intent intentForDeepLinkMethod1563(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1564/{param1}") - public static Intent intentForDeepLinkMethod1564(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1565/{param1}") - public static Intent intentForDeepLinkMethod1565(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1566/{param1}") - public static Intent intentForDeepLinkMethod1566(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1567/{param1}") - public static Intent intentForDeepLinkMethod1567(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1568/{param1}") - public static Intent intentForDeepLinkMethod1568(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1569/{param1}") - public static Intent intentForDeepLinkMethod1569(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1570/{param1}") - public static Intent intentForDeepLinkMethod1570(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1571/{param1}") - public static Intent intentForDeepLinkMethod1571(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1572/{param1}") - public static Intent intentForDeepLinkMethod1572(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1573/{param1}") - public static Intent intentForDeepLinkMethod1573(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1574/{param1}") - public static Intent intentForDeepLinkMethod1574(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1575/{param1}") - public static Intent intentForDeepLinkMethod1575(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1576/{param1}") - public static Intent intentForDeepLinkMethod1576(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1577/{param1}") - public static Intent intentForDeepLinkMethod1577(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1578/{param1}") - public static Intent intentForDeepLinkMethod1578(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1579/{param1}") - public static Intent intentForDeepLinkMethod1579(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1580/{param1}") - public static Intent intentForDeepLinkMethod1580(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1581/{param1}") - public static Intent intentForDeepLinkMethod1581(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1582/{param1}") - public static Intent intentForDeepLinkMethod1582(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1583/{param1}") - public static Intent intentForDeepLinkMethod1583(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1584/{param1}") - public static Intent intentForDeepLinkMethod1584(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1585/{param1}") - public static Intent intentForDeepLinkMethod1585(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1586/{param1}") - public static Intent intentForDeepLinkMethod1586(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1587/{param1}") - public static Intent intentForDeepLinkMethod1587(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1588/{param1}") - public static Intent intentForDeepLinkMethod1588(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1589/{param1}") - public static Intent intentForDeepLinkMethod1589(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1590/{param1}") - public static Intent intentForDeepLinkMethod1590(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1591/{param1}") - public static Intent intentForDeepLinkMethod1591(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1592/{param1}") - public static Intent intentForDeepLinkMethod1592(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1593/{param1}") - public static Intent intentForDeepLinkMethod1593(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1594/{param1}") - public static Intent intentForDeepLinkMethod1594(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1595/{param1}") - public static Intent intentForDeepLinkMethod1595(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1596/{param1}") - public static Intent intentForDeepLinkMethod1596(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1597/{param1}") - public static Intent intentForDeepLinkMethod1597(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1598/{param1}") - public static Intent intentForDeepLinkMethod1598(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1599/{param1}") - public static Intent intentForDeepLinkMethod1599(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1600/{param1}") - public static Intent intentForDeepLinkMethod1600(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1601/{param1}") - public static Intent intentForDeepLinkMethod1601(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1602/{param1}") - public static Intent intentForDeepLinkMethod1602(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1603/{param1}") - public static Intent intentForDeepLinkMethod1603(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1604/{param1}") - public static Intent intentForDeepLinkMethod1604(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1605/{param1}") - public static Intent intentForDeepLinkMethod1605(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1606/{param1}") - public static Intent intentForDeepLinkMethod1606(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1607/{param1}") - public static Intent intentForDeepLinkMethod1607(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1608/{param1}") - public static Intent intentForDeepLinkMethod1608(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1609/{param1}") - public static Intent intentForDeepLinkMethod1609(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1610/{param1}") - public static Intent intentForDeepLinkMethod1610(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1611/{param1}") - public static Intent intentForDeepLinkMethod1611(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1612/{param1}") - public static Intent intentForDeepLinkMethod1612(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1613/{param1}") - public static Intent intentForDeepLinkMethod1613(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1614/{param1}") - public static Intent intentForDeepLinkMethod1614(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1615/{param1}") - public static Intent intentForDeepLinkMethod1615(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1616/{param1}") - public static Intent intentForDeepLinkMethod1616(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1617/{param1}") - public static Intent intentForDeepLinkMethod1617(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1618/{param1}") - public static Intent intentForDeepLinkMethod1618(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1619/{param1}") - public static Intent intentForDeepLinkMethod1619(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1620/{param1}") - public static Intent intentForDeepLinkMethod1620(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1621/{param1}") - public static Intent intentForDeepLinkMethod1621(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1622/{param1}") - public static Intent intentForDeepLinkMethod1622(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1623/{param1}") - public static Intent intentForDeepLinkMethod1623(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1624/{param1}") - public static Intent intentForDeepLinkMethod1624(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1625/{param1}") - public static Intent intentForDeepLinkMethod1625(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1626/{param1}") - public static Intent intentForDeepLinkMethod1626(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1627/{param1}") - public static Intent intentForDeepLinkMethod1627(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1628/{param1}") - public static Intent intentForDeepLinkMethod1628(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1629/{param1}") - public static Intent intentForDeepLinkMethod1629(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1630/{param1}") - public static Intent intentForDeepLinkMethod1630(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1631/{param1}") - public static Intent intentForDeepLinkMethod1631(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1632/{param1}") - public static Intent intentForDeepLinkMethod1632(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1633/{param1}") - public static Intent intentForDeepLinkMethod1633(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1634/{param1}") - public static Intent intentForDeepLinkMethod1634(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1635/{param1}") - public static Intent intentForDeepLinkMethod1635(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1636/{param1}") - public static Intent intentForDeepLinkMethod1636(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1637/{param1}") - public static Intent intentForDeepLinkMethod1637(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1638/{param1}") - public static Intent intentForDeepLinkMethod1638(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1639/{param1}") - public static Intent intentForDeepLinkMethod1639(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1640/{param1}") - public static Intent intentForDeepLinkMethod1640(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1641/{param1}") - public static Intent intentForDeepLinkMethod1641(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1642/{param1}") - public static Intent intentForDeepLinkMethod1642(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1643/{param1}") - public static Intent intentForDeepLinkMethod1643(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1644/{param1}") - public static Intent intentForDeepLinkMethod1644(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1645/{param1}") - public static Intent intentForDeepLinkMethod1645(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1646/{param1}") - public static Intent intentForDeepLinkMethod1646(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1647/{param1}") - public static Intent intentForDeepLinkMethod1647(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1648/{param1}") - public static Intent intentForDeepLinkMethod1648(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1649/{param1}") - public static Intent intentForDeepLinkMethod1649(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1650/{param1}") - public static Intent intentForDeepLinkMethod1650(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1651/{param1}") - public static Intent intentForDeepLinkMethod1651(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1652/{param1}") - public static Intent intentForDeepLinkMethod1652(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1653/{param1}") - public static Intent intentForDeepLinkMethod1653(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1654/{param1}") - public static Intent intentForDeepLinkMethod1654(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1655/{param1}") - public static Intent intentForDeepLinkMethod1655(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1656/{param1}") - public static Intent intentForDeepLinkMethod1656(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1657/{param1}") - public static Intent intentForDeepLinkMethod1657(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1658/{param1}") - public static Intent intentForDeepLinkMethod1658(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1659/{param1}") - public static Intent intentForDeepLinkMethod1659(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1660/{param1}") - public static Intent intentForDeepLinkMethod1660(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1661/{param1}") - public static Intent intentForDeepLinkMethod1661(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1662/{param1}") - public static Intent intentForDeepLinkMethod1662(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1663/{param1}") - public static Intent intentForDeepLinkMethod1663(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1664/{param1}") - public static Intent intentForDeepLinkMethod1664(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1665/{param1}") - public static Intent intentForDeepLinkMethod1665(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1666/{param1}") - public static Intent intentForDeepLinkMethod1666(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1667/{param1}") - public static Intent intentForDeepLinkMethod1667(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1668/{param1}") - public static Intent intentForDeepLinkMethod1668(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1669/{param1}") - public static Intent intentForDeepLinkMethod1669(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1670/{param1}") - public static Intent intentForDeepLinkMethod1670(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1671/{param1}") - public static Intent intentForDeepLinkMethod1671(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1672/{param1}") - public static Intent intentForDeepLinkMethod1672(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1673/{param1}") - public static Intent intentForDeepLinkMethod1673(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1674/{param1}") - public static Intent intentForDeepLinkMethod1674(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1675/{param1}") - public static Intent intentForDeepLinkMethod1675(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1676/{param1}") - public static Intent intentForDeepLinkMethod1676(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1677/{param1}") - public static Intent intentForDeepLinkMethod1677(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1678/{param1}") - public static Intent intentForDeepLinkMethod1678(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1679/{param1}") - public static Intent intentForDeepLinkMethod1679(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1680/{param1}") - public static Intent intentForDeepLinkMethod1680(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1681/{param1}") - public static Intent intentForDeepLinkMethod1681(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1682/{param1}") - public static Intent intentForDeepLinkMethod1682(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1683/{param1}") - public static Intent intentForDeepLinkMethod1683(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1684/{param1}") - public static Intent intentForDeepLinkMethod1684(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1685/{param1}") - public static Intent intentForDeepLinkMethod1685(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1686/{param1}") - public static Intent intentForDeepLinkMethod1686(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1687/{param1}") - public static Intent intentForDeepLinkMethod1687(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1688/{param1}") - public static Intent intentForDeepLinkMethod1688(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1689/{param1}") - public static Intent intentForDeepLinkMethod1689(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1690/{param1}") - public static Intent intentForDeepLinkMethod1690(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1691/{param1}") - public static Intent intentForDeepLinkMethod1691(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1692/{param1}") - public static Intent intentForDeepLinkMethod1692(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1693/{param1}") - public static Intent intentForDeepLinkMethod1693(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1694/{param1}") - public static Intent intentForDeepLinkMethod1694(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1695/{param1}") - public static Intent intentForDeepLinkMethod1695(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1696/{param1}") - public static Intent intentForDeepLinkMethod1696(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1697/{param1}") - public static Intent intentForDeepLinkMethod1697(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1698/{param1}") - public static Intent intentForDeepLinkMethod1698(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1699/{param1}") - public static Intent intentForDeepLinkMethod1699(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1700/{param1}") - public static Intent intentForDeepLinkMethod1700(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1701/{param1}") - public static Intent intentForDeepLinkMethod1701(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1702/{param1}") - public static Intent intentForDeepLinkMethod1702(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1703/{param1}") - public static Intent intentForDeepLinkMethod1703(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1704/{param1}") - public static Intent intentForDeepLinkMethod1704(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1705/{param1}") - public static Intent intentForDeepLinkMethod1705(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1706/{param1}") - public static Intent intentForDeepLinkMethod1706(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1707/{param1}") - public static Intent intentForDeepLinkMethod1707(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1708/{param1}") - public static Intent intentForDeepLinkMethod1708(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1709/{param1}") - public static Intent intentForDeepLinkMethod1709(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1710/{param1}") - public static Intent intentForDeepLinkMethod1710(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1711/{param1}") - public static Intent intentForDeepLinkMethod1711(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1712/{param1}") - public static Intent intentForDeepLinkMethod1712(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1713/{param1}") - public static Intent intentForDeepLinkMethod1713(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1714/{param1}") - public static Intent intentForDeepLinkMethod1714(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1715/{param1}") - public static Intent intentForDeepLinkMethod1715(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1716/{param1}") - public static Intent intentForDeepLinkMethod1716(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1717/{param1}") - public static Intent intentForDeepLinkMethod1717(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1718/{param1}") - public static Intent intentForDeepLinkMethod1718(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1719/{param1}") - public static Intent intentForDeepLinkMethod1719(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1720/{param1}") - public static Intent intentForDeepLinkMethod1720(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1721/{param1}") - public static Intent intentForDeepLinkMethod1721(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1722/{param1}") - public static Intent intentForDeepLinkMethod1722(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1723/{param1}") - public static Intent intentForDeepLinkMethod1723(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1724/{param1}") - public static Intent intentForDeepLinkMethod1724(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1725/{param1}") - public static Intent intentForDeepLinkMethod1725(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1726/{param1}") - public static Intent intentForDeepLinkMethod1726(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1727/{param1}") - public static Intent intentForDeepLinkMethod1727(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1728/{param1}") - public static Intent intentForDeepLinkMethod1728(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1729/{param1}") - public static Intent intentForDeepLinkMethod1729(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1730/{param1}") - public static Intent intentForDeepLinkMethod1730(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1731/{param1}") - public static Intent intentForDeepLinkMethod1731(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1732/{param1}") - public static Intent intentForDeepLinkMethod1732(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1733/{param1}") - public static Intent intentForDeepLinkMethod1733(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1734/{param1}") - public static Intent intentForDeepLinkMethod1734(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1735/{param1}") - public static Intent intentForDeepLinkMethod1735(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1736/{param1}") - public static Intent intentForDeepLinkMethod1736(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1737/{param1}") - public static Intent intentForDeepLinkMethod1737(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1738/{param1}") - public static Intent intentForDeepLinkMethod1738(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1739/{param1}") - public static Intent intentForDeepLinkMethod1739(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1740/{param1}") - public static Intent intentForDeepLinkMethod1740(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1741/{param1}") - public static Intent intentForDeepLinkMethod1741(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1742/{param1}") - public static Intent intentForDeepLinkMethod1742(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1743/{param1}") - public static Intent intentForDeepLinkMethod1743(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1744/{param1}") - public static Intent intentForDeepLinkMethod1744(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1745/{param1}") - public static Intent intentForDeepLinkMethod1745(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1746/{param1}") - public static Intent intentForDeepLinkMethod1746(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1747/{param1}") - public static Intent intentForDeepLinkMethod1747(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1748/{param1}") - public static Intent intentForDeepLinkMethod1748(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1749/{param1}") - public static Intent intentForDeepLinkMethod1749(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1750/{param1}") - public static Intent intentForDeepLinkMethod1750(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1751/{param1}") - public static Intent intentForDeepLinkMethod1751(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1752/{param1}") - public static Intent intentForDeepLinkMethod1752(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1753/{param1}") - public static Intent intentForDeepLinkMethod1753(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1754/{param1}") - public static Intent intentForDeepLinkMethod1754(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1755/{param1}") - public static Intent intentForDeepLinkMethod1755(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1756/{param1}") - public static Intent intentForDeepLinkMethod1756(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1757/{param1}") - public static Intent intentForDeepLinkMethod1757(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1758/{param1}") - public static Intent intentForDeepLinkMethod1758(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1759/{param1}") - public static Intent intentForDeepLinkMethod1759(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1760/{param1}") - public static Intent intentForDeepLinkMethod1760(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1761/{param1}") - public static Intent intentForDeepLinkMethod1761(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1762/{param1}") - public static Intent intentForDeepLinkMethod1762(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1763/{param1}") - public static Intent intentForDeepLinkMethod1763(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1764/{param1}") - public static Intent intentForDeepLinkMethod1764(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1765/{param1}") - public static Intent intentForDeepLinkMethod1765(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1766/{param1}") - public static Intent intentForDeepLinkMethod1766(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1767/{param1}") - public static Intent intentForDeepLinkMethod1767(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1768/{param1}") - public static Intent intentForDeepLinkMethod1768(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1769/{param1}") - public static Intent intentForDeepLinkMethod1769(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1770/{param1}") - public static Intent intentForDeepLinkMethod1770(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1771/{param1}") - public static Intent intentForDeepLinkMethod1771(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1772/{param1}") - public static Intent intentForDeepLinkMethod1772(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1773/{param1}") - public static Intent intentForDeepLinkMethod1773(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1774/{param1}") - public static Intent intentForDeepLinkMethod1774(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1775/{param1}") - public static Intent intentForDeepLinkMethod1775(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1776/{param1}") - public static Intent intentForDeepLinkMethod1776(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1777/{param1}") - public static Intent intentForDeepLinkMethod1777(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1778/{param1}") - public static Intent intentForDeepLinkMethod1778(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1779/{param1}") - public static Intent intentForDeepLinkMethod1779(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1780/{param1}") - public static Intent intentForDeepLinkMethod1780(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1781/{param1}") - public static Intent intentForDeepLinkMethod1781(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1782/{param1}") - public static Intent intentForDeepLinkMethod1782(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1783/{param1}") - public static Intent intentForDeepLinkMethod1783(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1784/{param1}") - public static Intent intentForDeepLinkMethod1784(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1785/{param1}") - public static Intent intentForDeepLinkMethod1785(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1786/{param1}") - public static Intent intentForDeepLinkMethod1786(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1787/{param1}") - public static Intent intentForDeepLinkMethod1787(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1788/{param1}") - public static Intent intentForDeepLinkMethod1788(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1789/{param1}") - public static Intent intentForDeepLinkMethod1789(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1790/{param1}") - public static Intent intentForDeepLinkMethod1790(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1791/{param1}") - public static Intent intentForDeepLinkMethod1791(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1792/{param1}") - public static Intent intentForDeepLinkMethod1792(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1793/{param1}") - public static Intent intentForDeepLinkMethod1793(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1794/{param1}") - public static Intent intentForDeepLinkMethod1794(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1795/{param1}") - public static Intent intentForDeepLinkMethod1795(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1796/{param1}") - public static Intent intentForDeepLinkMethod1796(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1797/{param1}") - public static Intent intentForDeepLinkMethod1797(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1798/{param1}") - public static Intent intentForDeepLinkMethod1798(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1799/{param1}") - public static Intent intentForDeepLinkMethod1799(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1800/{param1}") - public static Intent intentForDeepLinkMethod1800(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1801/{param1}") - public static Intent intentForDeepLinkMethod1801(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1802/{param1}") - public static Intent intentForDeepLinkMethod1802(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1803/{param1}") - public static Intent intentForDeepLinkMethod1803(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1804/{param1}") - public static Intent intentForDeepLinkMethod1804(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1805/{param1}") - public static Intent intentForDeepLinkMethod1805(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1806/{param1}") - public static Intent intentForDeepLinkMethod1806(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1807/{param1}") - public static Intent intentForDeepLinkMethod1807(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1808/{param1}") - public static Intent intentForDeepLinkMethod1808(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1809/{param1}") - public static Intent intentForDeepLinkMethod1809(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1810/{param1}") - public static Intent intentForDeepLinkMethod1810(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1811/{param1}") - public static Intent intentForDeepLinkMethod1811(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1812/{param1}") - public static Intent intentForDeepLinkMethod1812(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1813/{param1}") - public static Intent intentForDeepLinkMethod1813(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1814/{param1}") - public static Intent intentForDeepLinkMethod1814(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1815/{param1}") - public static Intent intentForDeepLinkMethod1815(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1816/{param1}") - public static Intent intentForDeepLinkMethod1816(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1817/{param1}") - public static Intent intentForDeepLinkMethod1817(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1818/{param1}") - public static Intent intentForDeepLinkMethod1818(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1819/{param1}") - public static Intent intentForDeepLinkMethod1819(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1820/{param1}") - public static Intent intentForDeepLinkMethod1820(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1821/{param1}") - public static Intent intentForDeepLinkMethod1821(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1822/{param1}") - public static Intent intentForDeepLinkMethod1822(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1823/{param1}") - public static Intent intentForDeepLinkMethod1823(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1824/{param1}") - public static Intent intentForDeepLinkMethod1824(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1825/{param1}") - public static Intent intentForDeepLinkMethod1825(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1826/{param1}") - public static Intent intentForDeepLinkMethod1826(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1827/{param1}") - public static Intent intentForDeepLinkMethod1827(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1828/{param1}") - public static Intent intentForDeepLinkMethod1828(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1829/{param1}") - public static Intent intentForDeepLinkMethod1829(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1830/{param1}") - public static Intent intentForDeepLinkMethod1830(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1831/{param1}") - public static Intent intentForDeepLinkMethod1831(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1832/{param1}") - public static Intent intentForDeepLinkMethod1832(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1833/{param1}") - public static Intent intentForDeepLinkMethod1833(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1834/{param1}") - public static Intent intentForDeepLinkMethod1834(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1835/{param1}") - public static Intent intentForDeepLinkMethod1835(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1836/{param1}") - public static Intent intentForDeepLinkMethod1836(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1837/{param1}") - public static Intent intentForDeepLinkMethod1837(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1838/{param1}") - public static Intent intentForDeepLinkMethod1838(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1839/{param1}") - public static Intent intentForDeepLinkMethod1839(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1840/{param1}") - public static Intent intentForDeepLinkMethod1840(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1841/{param1}") - public static Intent intentForDeepLinkMethod1841(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1842/{param1}") - public static Intent intentForDeepLinkMethod1842(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1843/{param1}") - public static Intent intentForDeepLinkMethod1843(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1844/{param1}") - public static Intent intentForDeepLinkMethod1844(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1845/{param1}") - public static Intent intentForDeepLinkMethod1845(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1846/{param1}") - public static Intent intentForDeepLinkMethod1846(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1847/{param1}") - public static Intent intentForDeepLinkMethod1847(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1848/{param1}") - public static Intent intentForDeepLinkMethod1848(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1849/{param1}") - public static Intent intentForDeepLinkMethod1849(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1850/{param1}") - public static Intent intentForDeepLinkMethod1850(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1851/{param1}") - public static Intent intentForDeepLinkMethod1851(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1852/{param1}") - public static Intent intentForDeepLinkMethod1852(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1853/{param1}") - public static Intent intentForDeepLinkMethod1853(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1854/{param1}") - public static Intent intentForDeepLinkMethod1854(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1855/{param1}") - public static Intent intentForDeepLinkMethod1855(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1856/{param1}") - public static Intent intentForDeepLinkMethod1856(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1857/{param1}") - public static Intent intentForDeepLinkMethod1857(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1858/{param1}") - public static Intent intentForDeepLinkMethod1858(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1859/{param1}") - public static Intent intentForDeepLinkMethod1859(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1860/{param1}") - public static Intent intentForDeepLinkMethod1860(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1861/{param1}") - public static Intent intentForDeepLinkMethod1861(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1862/{param1}") - public static Intent intentForDeepLinkMethod1862(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1863/{param1}") - public static Intent intentForDeepLinkMethod1863(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1864/{param1}") - public static Intent intentForDeepLinkMethod1864(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1865/{param1}") - public static Intent intentForDeepLinkMethod1865(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1866/{param1}") - public static Intent intentForDeepLinkMethod1866(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1867/{param1}") - public static Intent intentForDeepLinkMethod1867(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1868/{param1}") - public static Intent intentForDeepLinkMethod1868(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1869/{param1}") - public static Intent intentForDeepLinkMethod1869(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1870/{param1}") - public static Intent intentForDeepLinkMethod1870(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1871/{param1}") - public static Intent intentForDeepLinkMethod1871(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1872/{param1}") - public static Intent intentForDeepLinkMethod1872(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1873/{param1}") - public static Intent intentForDeepLinkMethod1873(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1874/{param1}") - public static Intent intentForDeepLinkMethod1874(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1875/{param1}") - public static Intent intentForDeepLinkMethod1875(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1876/{param1}") - public static Intent intentForDeepLinkMethod1876(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1877/{param1}") - public static Intent intentForDeepLinkMethod1877(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1878/{param1}") - public static Intent intentForDeepLinkMethod1878(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1879/{param1}") - public static Intent intentForDeepLinkMethod1879(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1880/{param1}") - public static Intent intentForDeepLinkMethod1880(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1881/{param1}") - public static Intent intentForDeepLinkMethod1881(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1882/{param1}") - public static Intent intentForDeepLinkMethod1882(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1883/{param1}") - public static Intent intentForDeepLinkMethod1883(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1884/{param1}") - public static Intent intentForDeepLinkMethod1884(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1885/{param1}") - public static Intent intentForDeepLinkMethod1885(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1886/{param1}") - public static Intent intentForDeepLinkMethod1886(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1887/{param1}") - public static Intent intentForDeepLinkMethod1887(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1888/{param1}") - public static Intent intentForDeepLinkMethod1888(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1889/{param1}") - public static Intent intentForDeepLinkMethod1889(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1890/{param1}") - public static Intent intentForDeepLinkMethod1890(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1891/{param1}") - public static Intent intentForDeepLinkMethod1891(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1892/{param1}") - public static Intent intentForDeepLinkMethod1892(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1893/{param1}") - public static Intent intentForDeepLinkMethod1893(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1894/{param1}") - public static Intent intentForDeepLinkMethod1894(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1895/{param1}") - public static Intent intentForDeepLinkMethod1895(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1896/{param1}") - public static Intent intentForDeepLinkMethod1896(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1897/{param1}") - public static Intent intentForDeepLinkMethod1897(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1898/{param1}") - public static Intent intentForDeepLinkMethod1898(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1899/{param1}") - public static Intent intentForDeepLinkMethod1899(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1900/{param1}") - public static Intent intentForDeepLinkMethod1900(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1901/{param1}") - public static Intent intentForDeepLinkMethod1901(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1902/{param1}") - public static Intent intentForDeepLinkMethod1902(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1903/{param1}") - public static Intent intentForDeepLinkMethod1903(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1904/{param1}") - public static Intent intentForDeepLinkMethod1904(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1905/{param1}") - public static Intent intentForDeepLinkMethod1905(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1906/{param1}") - public static Intent intentForDeepLinkMethod1906(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1907/{param1}") - public static Intent intentForDeepLinkMethod1907(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1908/{param1}") - public static Intent intentForDeepLinkMethod1908(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1909/{param1}") - public static Intent intentForDeepLinkMethod1909(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1910/{param1}") - public static Intent intentForDeepLinkMethod1910(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1911/{param1}") - public static Intent intentForDeepLinkMethod1911(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1912/{param1}") - public static Intent intentForDeepLinkMethod1912(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1913/{param1}") - public static Intent intentForDeepLinkMethod1913(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1914/{param1}") - public static Intent intentForDeepLinkMethod1914(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1915/{param1}") - public static Intent intentForDeepLinkMethod1915(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1916/{param1}") - public static Intent intentForDeepLinkMethod1916(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1917/{param1}") - public static Intent intentForDeepLinkMethod1917(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1918/{param1}") - public static Intent intentForDeepLinkMethod1918(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1919/{param1}") - public static Intent intentForDeepLinkMethod1919(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1920/{param1}") - public static Intent intentForDeepLinkMethod1920(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1921/{param1}") - public static Intent intentForDeepLinkMethod1921(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1922/{param1}") - public static Intent intentForDeepLinkMethod1922(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1923/{param1}") - public static Intent intentForDeepLinkMethod1923(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1924/{param1}") - public static Intent intentForDeepLinkMethod1924(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1925/{param1}") - public static Intent intentForDeepLinkMethod1925(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1926/{param1}") - public static Intent intentForDeepLinkMethod1926(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1927/{param1}") - public static Intent intentForDeepLinkMethod1927(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1928/{param1}") - public static Intent intentForDeepLinkMethod1928(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1929/{param1}") - public static Intent intentForDeepLinkMethod1929(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1930/{param1}") - public static Intent intentForDeepLinkMethod1930(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1931/{param1}") - public static Intent intentForDeepLinkMethod1931(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1932/{param1}") - public static Intent intentForDeepLinkMethod1932(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1933/{param1}") - public static Intent intentForDeepLinkMethod1933(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1934/{param1}") - public static Intent intentForDeepLinkMethod1934(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1935/{param1}") - public static Intent intentForDeepLinkMethod1935(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1936/{param1}") - public static Intent intentForDeepLinkMethod1936(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1937/{param1}") - public static Intent intentForDeepLinkMethod1937(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1938/{param1}") - public static Intent intentForDeepLinkMethod1938(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1939/{param1}") - public static Intent intentForDeepLinkMethod1939(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1940/{param1}") - public static Intent intentForDeepLinkMethod1940(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1941/{param1}") - public static Intent intentForDeepLinkMethod1941(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1942/{param1}") - public static Intent intentForDeepLinkMethod1942(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1943/{param1}") - public static Intent intentForDeepLinkMethod1943(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1944/{param1}") - public static Intent intentForDeepLinkMethod1944(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1945/{param1}") - public static Intent intentForDeepLinkMethod1945(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1946/{param1}") - public static Intent intentForDeepLinkMethod1946(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1947/{param1}") - public static Intent intentForDeepLinkMethod1947(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1948/{param1}") - public static Intent intentForDeepLinkMethod1948(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1949/{param1}") - public static Intent intentForDeepLinkMethod1949(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1950/{param1}") - public static Intent intentForDeepLinkMethod1950(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1951/{param1}") - public static Intent intentForDeepLinkMethod1951(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1952/{param1}") - public static Intent intentForDeepLinkMethod1952(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1953/{param1}") - public static Intent intentForDeepLinkMethod1953(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1954/{param1}") - public static Intent intentForDeepLinkMethod1954(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1955/{param1}") - public static Intent intentForDeepLinkMethod1955(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1956/{param1}") - public static Intent intentForDeepLinkMethod1956(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1957/{param1}") - public static Intent intentForDeepLinkMethod1957(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1958/{param1}") - public static Intent intentForDeepLinkMethod1958(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1959/{param1}") - public static Intent intentForDeepLinkMethod1959(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1960/{param1}") - public static Intent intentForDeepLinkMethod1960(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1961/{param1}") - public static Intent intentForDeepLinkMethod1961(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1962/{param1}") - public static Intent intentForDeepLinkMethod1962(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1963/{param1}") - public static Intent intentForDeepLinkMethod1963(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1964/{param1}") - public static Intent intentForDeepLinkMethod1964(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1965/{param1}") - public static Intent intentForDeepLinkMethod1965(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1966/{param1}") - public static Intent intentForDeepLinkMethod1966(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1967/{param1}") - public static Intent intentForDeepLinkMethod1967(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1968/{param1}") - public static Intent intentForDeepLinkMethod1968(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1969/{param1}") - public static Intent intentForDeepLinkMethod1969(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1970/{param1}") - public static Intent intentForDeepLinkMethod1970(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1971/{param1}") - public static Intent intentForDeepLinkMethod1971(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1972/{param1}") - public static Intent intentForDeepLinkMethod1972(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1973/{param1}") - public static Intent intentForDeepLinkMethod1973(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1974/{param1}") - public static Intent intentForDeepLinkMethod1974(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1975/{param1}") - public static Intent intentForDeepLinkMethod1975(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1976/{param1}") - public static Intent intentForDeepLinkMethod1976(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1977/{param1}") - public static Intent intentForDeepLinkMethod1977(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1978/{param1}") - public static Intent intentForDeepLinkMethod1978(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1979/{param1}") - public static Intent intentForDeepLinkMethod1979(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1980/{param1}") - public static Intent intentForDeepLinkMethod1980(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1981/{param1}") - public static Intent intentForDeepLinkMethod1981(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1982/{param1}") - public static Intent intentForDeepLinkMethod1982(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1983/{param1}") - public static Intent intentForDeepLinkMethod1983(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1984/{param1}") - public static Intent intentForDeepLinkMethod1984(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1985/{param1}") - public static Intent intentForDeepLinkMethod1985(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1986/{param1}") - public static Intent intentForDeepLinkMethod1986(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1987/{param1}") - public static Intent intentForDeepLinkMethod1987(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1988/{param1}") - public static Intent intentForDeepLinkMethod1988(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1989/{param1}") - public static Intent intentForDeepLinkMethod1989(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1990/{param1}") - public static Intent intentForDeepLinkMethod1990(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1991/{param1}") - public static Intent intentForDeepLinkMethod1991(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1992/{param1}") - public static Intent intentForDeepLinkMethod1992(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1993/{param1}") - public static Intent intentForDeepLinkMethod1993(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1994/{param1}") - public static Intent intentForDeepLinkMethod1994(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1995/{param1}") - public static Intent intentForDeepLinkMethod1995(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1996/{param1}") - public static Intent intentForDeepLinkMethod1996(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1997/{param1}") - public static Intent intentForDeepLinkMethod1997(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1998/{param1}") - public static Intent intentForDeepLinkMethod1998(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink1999/{param1}") - public static Intent intentForDeepLinkMethod1999(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - @DeepLink("dld://methodDeepLink2000/{param1}") - public static Intent intentForDeepLinkMethod2000(Context context) { - return new Intent(context, ScaleTestActivity.class).setAction(ACTION_DEEP_LINK_METHOD); - } - - private void showToast(String message) { - Toast.makeText(this, "Deep Link: " + message, Toast.LENGTH_SHORT).show(); - } -} diff --git a/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.kt b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.kt new file mode 100644 index 00000000..351a0c01 --- /dev/null +++ b/sample-benchmarkable-library/src/main/java/com/airbnb/deeplinkdispatch/sample/benchmarkable/ScaleTestActivity.kt @@ -0,0 +1,10072 @@ +/* + * Copyright (C) 2015 Airbnb, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.airbnb.deeplinkdispatch.sample.benchmarkable + +import android.content.Context +import android.content.Intent +import android.os.Bundle +import android.util.Log +import android.widget.Toast +import androidx.appcompat.app.AppCompatActivity +import androidx.core.app.ActivityCompat +import com.airbnb.deeplinkdispatch.DeepLink + +/** + * Activity with 2k deeplinks to test DLD performance at scale + */ +class ScaleTestActivity : AppCompatActivity() { + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + setContentView(R.layout.scale_activity_main) + + val intent = intent + if (intent.getBooleanExtra(DeepLink.IS_DEEP_LINK, false)) { + val parameters = intent.extras + Log.d(TAG, "Deeplink params: $parameters") + + var toastMessage = when { + ACTION_DEEP_LINK_METHOD == intent.action -> "method with param1:" + parameters?.getString("param1") + ACTION_DEEP_LINK_COMPLEX == intent.action -> parameters?.getString("arbitraryNumber") ?: "" + parameters?.containsKey("arg") == true -> "class and found arg:" + parameters.getString("arg") + else -> "class" + } + + // You can pass a query parameter with the URI, and it's also in parameters, like + // dld://classDeepLink?qp=123 + if (parameters?.containsKey("qp") == true) { + toastMessage += " with query parameter " + parameters.getString("qp") + } + val referrer = ActivityCompat.getReferrer(this) + if (referrer != null) { + toastMessage += " and referrer: $referrer" + } + + showToast(toastMessage) + } + } + + private fun showToast(message: String) { + Toast.makeText(this, "Deep Link: $message", Toast.LENGTH_SHORT).show() + } + + companion object { + private const val ACTION_DEEP_LINK_METHOD = "deep_link_method" + private const val ACTION_DEEP_LINK_COMPLEX = "deep_link_complex" + private val TAG = ScaleTestActivity::class.java.simpleName + + @DeepLink(value = ["dld://methodDeepLink1/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink2/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod2(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink3/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod3(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink4/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod4(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink5/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod5(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink6/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod6(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink7/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod7(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink8/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod8(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink9/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod9(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink10/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod10(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink11/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod11(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink12/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod12(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink13/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod13(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink14/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod14(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink15/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod15(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink16/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod16(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink17/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod17(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink18/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod18(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink19/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod19(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink20/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod20(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink21/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod21(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink22/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod22(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink23/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod23(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink24/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod24(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink25/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod25(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink26/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod26(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink27/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod27(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink28/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod28(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink29/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod29(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink30/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod30(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink31/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod31(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink32/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod32(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink33/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod33(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink34/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod34(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink35/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod35(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink36/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod36(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink37/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod37(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink38/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod38(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink39/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod39(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink40/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod40(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink41/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod41(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink42/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod42(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink43/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod43(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink44/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod44(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink45/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod45(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink46/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod46(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink47/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod47(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink48/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod48(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink49/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod49(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink50/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod50(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink51/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod51(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink52/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod52(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink53/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod53(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink54/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod54(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink55/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod55(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink56/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod56(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink57/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod57(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink58/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod58(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink59/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod59(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink60/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod60(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink61/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod61(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink62/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod62(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink63/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod63(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink64/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod64(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink65/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod65(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink66/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod66(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink67/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod67(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink68/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod68(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink69/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod69(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink70/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod70(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink71/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod71(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink72/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod72(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink73/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod73(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink74/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod74(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink75/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod75(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink76/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod76(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink77/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod77(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink78/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod78(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink79/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod79(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink80/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod80(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink81/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod81(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink82/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod82(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink83/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod83(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink84/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod84(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink85/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod85(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink86/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod86(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink87/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod87(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink88/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod88(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink89/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod89(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink90/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod90(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink91/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod91(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink92/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod92(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink93/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod93(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink94/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod94(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink95/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod95(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink96/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod96(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink97/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod97(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink98/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod98(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink99/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod99(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink100/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod100(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink101/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod101(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink102/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod102(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink103/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod103(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink104/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod104(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink105/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod105(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink106/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod106(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink107/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod107(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink108/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod108(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink109/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod109(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink110/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod110(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink111/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod111(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink112/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod112(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink113/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod113(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink114/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod114(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink115/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod115(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink116/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod116(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink117/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod117(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink118/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod118(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink119/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod119(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink120/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod120(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink121/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod121(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink122/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod122(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink123/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod123(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink124/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod124(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink125/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod125(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink126/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod126(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink127/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod127(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink128/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod128(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink129/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod129(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink130/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod130(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink131/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod131(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink132/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod132(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink133/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod133(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink134/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod134(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink135/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod135(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink136/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod136(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink137/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod137(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink138/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod138(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink139/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod139(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink140/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod140(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink141/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod141(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink142/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod142(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink143/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod143(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink144/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod144(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink145/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod145(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink146/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod146(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink147/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod147(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink148/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod148(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink149/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod149(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink150/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod150(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink151/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod151(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink152/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod152(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink153/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod153(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink154/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod154(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink155/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod155(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink156/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod156(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink157/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod157(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink158/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod158(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink159/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod159(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink160/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod160(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink161/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod161(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink162/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod162(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink163/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod163(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink164/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod164(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink165/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod165(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink166/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod166(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink167/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod167(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink168/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod168(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink169/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod169(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink170/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod170(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink171/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod171(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink172/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod172(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink173/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod173(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink174/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod174(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink175/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod175(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink176/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod176(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink177/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod177(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink178/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod178(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink179/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod179(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink180/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod180(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink181/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod181(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink182/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod182(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink183/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod183(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink184/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod184(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink185/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod185(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink186/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod186(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink187/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod187(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink188/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod188(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink189/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod189(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink190/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod190(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink191/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod191(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink192/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod192(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink193/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod193(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink194/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod194(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink195/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod195(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink196/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod196(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink197/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod197(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink198/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod198(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink199/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod199(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink200/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod200(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink201/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod201(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink202/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod202(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink203/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod203(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink204/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod204(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink205/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod205(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink206/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod206(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink207/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod207(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink208/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod208(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink209/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod209(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink210/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod210(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink211/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod211(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink212/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod212(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink213/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod213(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink214/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod214(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink215/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod215(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink216/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod216(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink217/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod217(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink218/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod218(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink219/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod219(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink220/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod220(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink221/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod221(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink222/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod222(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink223/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod223(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink224/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod224(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink225/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod225(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink226/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod226(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink227/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod227(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink228/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod228(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink229/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod229(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink230/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod230(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink231/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod231(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink232/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod232(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink233/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod233(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink234/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod234(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink235/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod235(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink236/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod236(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink237/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod237(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink238/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod238(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink239/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod239(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink240/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod240(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink241/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod241(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink242/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod242(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink243/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod243(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink244/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod244(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink245/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod245(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink246/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod246(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink247/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod247(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink248/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod248(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink249/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod249(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink250/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod250(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink251/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod251(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink252/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod252(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink253/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod253(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink254/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod254(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink255/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod255(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink256/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod256(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink257/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod257(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink258/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod258(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink259/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod259(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink260/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod260(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink261/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod261(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink262/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod262(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink263/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod263(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink264/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod264(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink265/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod265(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink266/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod266(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink267/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod267(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink268/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod268(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink269/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod269(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink270/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod270(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink271/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod271(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink272/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod272(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink273/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod273(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink274/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod274(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink275/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod275(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink276/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod276(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink277/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod277(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink278/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod278(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink279/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod279(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink280/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod280(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink281/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod281(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink282/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod282(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink283/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod283(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink284/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod284(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink285/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod285(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink286/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod286(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink287/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod287(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink288/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod288(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink289/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod289(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink290/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod290(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink291/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod291(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink292/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod292(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink293/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod293(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink294/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod294(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink295/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod295(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink296/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod296(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink297/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod297(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink298/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod298(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink299/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod299(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink300/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod300(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink301/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod301(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink302/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod302(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink303/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod303(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink304/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod304(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink305/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod305(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink306/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod306(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink307/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod307(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink308/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod308(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink309/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod309(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink310/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod310(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink311/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod311(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink312/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod312(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink313/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod313(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink314/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod314(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink315/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod315(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink316/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod316(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink317/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod317(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink318/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod318(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink319/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod319(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink320/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod320(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink321/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod321(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink322/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod322(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink323/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod323(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink324/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod324(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink325/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod325(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink326/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod326(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink327/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod327(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink328/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod328(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink329/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod329(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink330/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod330(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink331/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod331(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink332/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod332(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink333/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod333(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink334/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod334(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink335/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod335(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink336/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod336(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink337/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod337(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink338/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod338(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink339/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod339(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink340/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod340(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink341/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod341(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink342/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod342(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink343/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod343(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink344/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod344(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink345/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod345(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink346/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod346(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink347/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod347(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink348/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod348(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink349/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod349(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink350/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod350(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink351/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod351(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink352/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod352(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink353/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod353(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink354/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod354(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink355/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod355(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink356/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod356(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink357/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod357(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink358/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod358(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink359/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod359(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink360/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod360(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink361/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod361(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink362/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod362(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink363/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod363(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink364/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod364(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink365/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod365(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink366/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod366(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink367/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod367(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink368/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod368(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink369/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod369(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink370/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod370(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink371/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod371(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink372/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod372(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink373/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod373(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink374/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod374(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink375/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod375(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink376/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod376(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink377/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod377(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink378/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod378(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink379/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod379(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink380/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod380(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink381/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod381(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink382/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod382(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink383/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod383(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink384/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod384(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink385/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod385(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink386/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod386(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink387/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod387(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink388/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod388(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink389/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod389(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink390/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod390(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink391/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod391(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink392/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod392(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink393/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod393(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink394/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod394(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink395/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod395(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink396/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod396(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink397/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod397(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink398/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod398(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink399/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod399(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink400/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod400(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink401/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod401(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink402/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod402(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink403/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod403(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink404/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod404(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink405/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod405(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink406/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod406(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink407/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod407(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink408/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod408(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink409/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod409(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink410/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod410(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink411/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod411(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink412/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod412(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink413/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod413(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink414/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod414(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink415/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod415(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink416/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod416(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink417/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod417(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink418/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod418(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink419/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod419(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink420/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod420(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink421/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod421(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink422/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod422(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink423/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod423(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink424/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod424(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink425/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod425(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink426/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod426(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink427/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod427(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink428/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod428(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink429/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod429(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink430/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod430(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink431/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod431(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink432/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod432(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink433/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod433(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink434/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod434(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink435/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod435(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink436/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod436(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink437/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod437(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink438/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod438(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink439/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod439(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink440/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod440(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink441/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod441(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink442/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod442(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink443/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod443(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink444/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod444(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink445/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod445(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink446/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod446(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink447/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod447(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink448/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod448(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink449/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod449(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink450/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod450(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink451/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod451(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink452/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod452(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink453/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod453(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink454/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod454(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink455/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod455(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink456/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod456(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink457/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod457(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink458/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod458(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink459/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod459(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink460/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod460(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink461/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod461(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink462/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod462(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink463/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod463(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink464/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod464(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink465/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod465(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink466/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod466(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink467/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod467(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink468/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod468(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink469/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod469(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink470/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod470(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink471/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod471(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink472/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod472(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink473/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod473(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink474/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod474(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink475/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod475(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink476/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod476(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink477/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod477(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink478/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod478(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink479/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod479(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink480/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod480(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink481/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod481(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink482/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod482(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink483/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod483(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink484/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod484(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink485/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod485(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink486/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod486(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink487/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod487(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink488/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod488(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink489/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod489(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink490/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod490(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink491/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod491(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink492/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod492(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink493/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod493(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink494/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod494(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink495/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod495(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink496/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod496(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink497/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod497(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink498/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod498(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink499/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod499(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink500/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod500(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink501/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod501(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink502/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod502(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink503/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod503(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink504/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod504(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink505/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod505(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink506/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod506(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink507/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod507(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink508/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod508(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink509/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod509(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink510/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod510(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink511/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod511(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink512/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod512(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink513/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod513(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink514/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod514(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink515/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod515(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink516/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod516(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink517/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod517(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink518/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod518(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink519/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod519(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink520/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod520(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink521/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod521(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink522/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod522(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink523/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod523(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink524/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod524(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink525/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod525(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink526/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod526(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink527/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod527(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink528/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod528(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink529/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod529(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink530/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod530(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink531/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod531(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink532/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod532(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink533/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod533(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink534/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod534(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink535/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod535(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink536/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod536(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink537/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod537(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink538/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod538(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink539/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod539(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink540/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod540(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink541/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod541(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink542/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod542(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink543/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod543(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink544/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod544(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink545/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod545(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink546/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod546(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink547/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod547(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink548/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod548(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink549/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod549(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink550/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod550(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink551/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod551(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink552/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod552(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink553/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod553(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink554/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod554(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink555/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod555(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink556/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod556(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink557/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod557(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink558/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod558(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink559/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod559(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink560/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod560(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink561/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod561(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink562/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod562(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink563/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod563(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink564/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod564(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink565/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod565(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink566/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod566(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink567/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod567(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink568/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod568(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink569/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod569(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink570/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod570(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink571/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod571(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink572/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod572(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink573/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod573(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink574/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod574(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink575/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod575(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink576/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod576(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink577/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod577(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink578/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod578(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink579/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod579(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink580/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod580(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink581/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod581(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink582/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod582(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink583/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod583(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink584/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod584(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink585/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod585(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink586/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod586(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink587/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod587(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink588/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod588(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink589/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod589(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink590/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod590(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink591/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod591(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink592/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod592(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink593/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod593(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink594/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod594(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink595/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod595(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink596/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod596(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink597/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod597(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink598/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod598(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink599/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod599(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink600/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod600(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink601/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod601(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink602/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod602(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink603/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod603(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink604/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod604(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink605/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod605(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink606/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod606(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink607/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod607(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink608/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod608(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink609/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod609(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink610/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod610(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink611/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod611(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink612/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod612(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink613/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod613(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink614/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod614(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink615/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod615(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink616/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod616(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink617/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod617(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink618/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod618(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink619/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod619(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink620/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod620(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink621/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod621(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink622/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod622(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink623/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod623(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink624/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod624(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink625/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod625(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink626/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod626(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink627/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod627(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink628/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod628(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink629/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod629(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink630/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod630(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink631/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod631(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink632/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod632(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink633/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod633(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink634/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod634(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink635/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod635(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink636/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod636(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink637/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod637(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink638/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod638(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink639/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod639(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink640/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod640(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink641/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod641(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink642/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod642(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink643/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod643(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink644/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod644(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink645/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod645(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink646/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod646(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink647/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod647(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink648/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod648(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink649/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod649(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink650/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod650(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink651/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod651(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink652/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod652(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink653/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod653(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink654/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod654(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink655/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod655(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink656/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod656(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink657/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod657(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink658/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod658(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink659/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod659(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink660/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod660(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink661/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod661(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink662/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod662(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink663/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod663(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink664/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod664(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink665/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod665(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink666/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod666(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink667/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod667(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink668/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod668(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink669/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod669(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink670/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod670(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink671/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod671(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink672/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod672(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink673/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod673(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink674/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod674(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink675/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod675(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink676/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod676(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink677/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod677(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink678/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod678(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink679/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod679(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink680/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod680(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink681/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod681(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink682/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod682(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink683/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod683(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink684/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod684(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink685/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod685(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink686/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod686(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink687/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod687(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink688/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod688(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink689/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod689(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink690/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod690(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink691/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod691(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink692/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod692(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink693/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod693(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink694/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod694(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink695/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod695(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink696/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod696(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink697/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod697(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink698/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod698(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink699/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod699(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink700/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod700(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink701/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod701(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink702/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod702(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink703/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod703(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink704/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod704(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink705/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod705(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink706/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod706(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink707/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod707(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink708/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod708(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink709/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod709(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink710/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod710(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink711/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod711(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink712/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod712(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink713/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod713(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink714/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod714(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink715/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod715(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink716/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod716(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink717/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod717(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink718/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod718(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink719/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod719(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink720/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod720(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink721/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod721(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink722/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod722(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink723/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod723(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink724/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod724(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink725/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod725(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink726/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod726(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink727/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod727(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink728/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod728(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink729/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod729(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink730/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod730(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink731/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod731(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink732/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod732(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink733/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod733(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink734/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod734(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink735/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod735(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink736/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod736(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink737/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod737(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink738/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod738(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink739/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod739(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink740/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod740(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink741/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod741(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink742/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod742(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink743/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod743(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink744/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod744(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink745/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod745(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink746/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod746(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink747/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod747(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink748/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod748(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink749/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod749(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink750/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod750(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink751/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod751(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink752/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod752(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink753/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod753(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink754/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod754(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink755/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod755(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink756/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod756(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink757/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod757(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink758/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod758(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink759/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod759(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink760/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod760(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink761/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod761(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink762/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod762(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink763/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod763(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink764/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod764(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink765/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod765(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink766/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod766(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink767/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod767(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink768/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod768(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink769/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod769(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink770/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod770(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink771/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod771(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink772/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod772(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink773/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod773(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink774/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod774(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink775/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod775(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink776/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod776(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink777/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod777(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink778/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod778(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink779/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod779(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink780/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod780(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink781/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod781(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink782/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod782(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink783/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod783(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink784/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod784(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink785/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod785(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink786/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod786(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink787/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod787(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink788/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod788(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink789/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod789(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink790/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod790(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink791/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod791(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink792/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod792(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink793/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod793(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink794/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod794(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink795/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod795(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink796/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod796(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink797/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod797(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink798/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod798(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink799/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod799(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink800/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod800(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink801/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod801(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink802/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod802(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink803/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod803(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink804/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod804(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink805/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod805(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink806/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod806(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink807/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod807(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink808/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod808(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink809/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod809(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink810/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod810(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink811/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod811(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink812/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod812(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink813/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod813(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink814/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod814(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink815/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod815(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink816/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod816(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink817/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod817(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink818/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod818(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink819/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod819(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink820/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod820(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink821/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod821(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink822/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod822(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink823/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod823(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink824/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod824(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink825/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod825(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink826/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod826(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink827/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod827(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink828/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod828(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink829/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod829(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink830/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod830(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink831/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod831(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink832/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod832(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink833/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod833(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink834/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod834(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink835/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod835(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink836/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod836(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink837/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod837(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink838/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod838(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink839/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod839(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink840/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod840(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink841/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod841(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink842/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod842(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink843/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod843(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink844/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod844(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink845/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod845(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink846/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod846(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink847/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod847(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink848/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod848(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink849/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod849(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink850/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod850(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink851/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod851(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink852/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod852(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink853/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod853(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink854/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod854(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink855/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod855(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink856/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod856(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink857/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod857(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink858/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod858(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink859/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod859(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink860/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod860(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink861/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod861(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink862/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod862(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink863/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod863(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink864/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod864(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink865/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod865(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink866/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod866(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink867/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod867(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink868/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod868(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink869/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod869(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink870/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod870(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink871/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod871(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink872/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod872(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink873/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod873(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink874/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod874(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink875/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod875(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink876/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod876(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink877/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod877(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink878/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod878(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink879/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod879(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink880/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod880(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink881/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod881(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink882/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod882(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink883/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod883(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink884/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod884(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink885/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod885(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink886/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod886(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink887/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod887(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink888/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod888(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink889/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod889(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink890/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod890(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink891/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod891(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink892/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod892(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink893/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod893(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink894/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod894(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink895/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod895(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink896/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod896(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink897/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod897(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink898/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod898(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink899/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod899(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink900/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod900(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink901/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod901(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink902/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod902(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink903/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod903(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink904/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod904(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink905/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod905(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink906/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod906(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink907/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod907(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink908/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod908(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink909/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod909(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink910/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod910(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink911/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod911(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink912/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod912(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink913/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod913(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink914/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod914(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink915/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod915(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink916/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod916(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink917/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod917(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink918/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod918(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink919/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod919(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink920/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod920(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink921/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod921(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink922/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod922(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink923/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod923(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink924/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod924(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink925/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod925(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink926/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod926(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink927/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod927(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink928/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod928(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink929/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod929(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink930/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod930(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink931/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod931(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink932/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod932(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink933/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod933(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink934/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod934(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink935/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod935(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink936/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod936(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink937/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod937(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink938/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod938(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink939/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod939(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink940/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod940(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink941/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod941(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink942/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod942(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink943/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod943(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink944/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod944(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink945/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod945(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink946/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod946(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink947/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod947(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink948/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod948(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink949/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod949(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink950/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod950(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink951/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod951(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink952/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod952(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink953/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod953(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink954/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod954(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink955/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod955(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink956/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod956(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink957/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod957(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink958/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod958(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink959/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod959(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink960/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod960(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink961/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod961(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink962/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod962(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink963/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod963(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink964/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod964(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink965/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod965(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink966/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod966(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink967/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod967(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink968/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod968(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink969/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod969(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink970/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod970(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink971/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod971(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink972/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod972(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink973/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod973(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink974/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod974(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink975/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod975(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink976/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod976(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink977/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod977(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink978/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod978(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink979/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod979(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink980/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod980(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink981/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod981(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink982/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod982(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink983/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod983(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink984/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod984(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink985/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod985(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink986/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod986(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink987/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod987(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink988/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod988(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink989/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod989(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink990/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod990(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink991/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod991(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink992/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod992(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink993/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod993(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink994/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod994(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink995/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod995(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink996/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod996(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink997/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod997(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink998/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod998(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink999/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod999(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1000/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1000(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1001/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1001(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1002/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1002(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1003/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1003(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1004/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1004(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1005/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1005(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1006/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1006(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1007/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1007(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1008/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1008(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1009/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1009(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1010/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1010(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1011/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1011(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1012/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1012(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1013/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1013(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1014/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1014(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1015/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1015(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1016/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1016(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1017/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1017(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1018/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1018(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1019/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1019(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1020/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1020(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1021/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1021(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1022/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1022(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1023/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1023(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1024/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1024(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1025/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1025(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1026/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1026(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1027/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1027(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1028/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1028(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1029/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1029(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1030/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1030(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1031/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1031(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1032/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1032(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1033/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1033(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1034/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1034(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1035/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1035(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1036/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1036(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1037/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1037(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1038/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1038(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1039/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1039(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1040/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1040(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1041/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1041(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1042/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1042(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1043/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1043(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1044/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1044(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1045/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1045(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1046/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1046(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1047/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1047(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1048/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1048(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1049/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1049(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1050/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1050(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1051/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1051(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1052/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1052(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1053/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1053(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1054/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1054(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1055/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1055(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1056/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1056(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1057/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1057(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1058/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1058(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1059/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1059(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1060/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1060(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1061/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1061(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1062/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1062(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1063/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1063(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1064/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1064(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1065/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1065(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1066/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1066(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1067/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1067(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1068/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1068(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1069/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1069(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1070/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1070(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1071/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1071(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1072/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1072(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1073/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1073(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1074/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1074(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1075/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1075(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1076/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1076(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1077/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1077(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1078/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1078(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1079/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1079(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1080/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1080(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1081/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1081(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1082/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1082(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1083/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1083(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1084/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1084(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1085/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1085(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1086/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1086(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1087/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1087(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1088/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1088(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1089/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1089(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1090/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1090(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1091/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1091(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1092/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1092(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1093/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1093(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1094/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1094(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1095/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1095(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1096/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1096(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1097/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1097(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1098/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1098(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1099/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1099(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1100/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1100(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1101/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1101(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1102/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1102(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1103/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1103(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1104/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1104(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1105/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1105(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1106/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1106(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1107/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1107(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1108/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1108(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1109/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1109(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1110/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1110(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1111/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1111(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1112/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1112(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1113/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1113(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1114/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1114(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1115/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1115(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1116/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1116(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1117/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1117(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1118/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1118(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1119/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1119(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1120/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1120(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1121/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1121(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1122/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1122(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1123/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1123(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1124/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1124(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1125/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1125(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1126/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1126(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1127/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1127(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1128/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1128(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1129/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1129(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1130/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1130(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1131/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1131(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1132/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1132(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1133/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1133(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1134/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1134(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1135/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1135(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1136/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1136(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1137/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1137(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1138/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1138(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1139/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1139(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1140/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1140(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1141/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1141(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1142/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1142(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1143/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1143(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1144/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1144(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1145/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1145(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1146/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1146(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1147/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1147(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1148/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1148(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1149/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1149(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1150/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1150(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1151/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1151(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1152/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1152(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1153/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1153(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1154/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1154(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1155/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1155(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1156/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1156(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1157/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1157(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1158/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1158(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1159/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1159(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1160/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1160(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1161/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1161(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1162/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1162(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1163/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1163(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1164/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1164(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1165/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1165(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1166/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1166(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1167/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1167(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1168/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1168(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1169/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1169(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1170/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1170(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1171/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1171(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1172/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1172(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1173/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1173(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1174/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1174(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1175/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1175(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1176/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1176(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1177/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1177(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1178/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1178(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1179/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1179(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1180/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1180(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1181/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1181(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1182/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1182(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1183/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1183(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1184/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1184(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1185/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1185(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1186/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1186(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1187/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1187(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1188/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1188(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1189/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1189(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1190/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1190(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1191/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1191(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1192/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1192(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1193/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1193(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1194/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1194(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1195/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1195(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1196/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1196(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1197/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1197(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1198/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1198(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1199/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1199(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1200/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1200(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1201/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1201(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1202/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1202(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1203/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1203(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1204/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1204(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1205/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1205(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1206/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1206(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1207/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1207(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1208/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1208(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1209/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1209(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1210/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1210(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1211/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1211(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1212/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1212(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1213/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1213(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1214/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1214(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1215/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1215(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1216/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1216(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1217/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1217(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1218/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1218(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1219/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1219(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1220/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1220(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1221/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1221(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1222/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1222(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1223/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1223(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1224/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1224(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1225/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1225(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1226/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1226(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1227/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1227(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1228/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1228(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1229/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1229(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1230/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1230(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1231/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1231(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1232/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1232(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1233/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1233(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1234/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1234(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1235/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1235(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1236/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1236(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1237/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1237(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1238/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1238(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1239/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1239(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1240/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1240(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1241/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1241(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1242/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1242(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1243/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1243(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1244/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1244(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1245/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1245(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1246/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1246(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1247/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1247(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1248/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1248(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1249/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1249(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1250/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1250(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1251/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1251(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1252/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1252(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1253/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1253(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1254/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1254(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1255/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1255(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1256/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1256(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1257/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1257(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1258/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1258(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1259/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1259(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1260/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1260(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1261/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1261(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1262/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1262(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1263/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1263(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1264/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1264(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1265/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1265(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1266/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1266(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1267/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1267(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1268/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1268(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1269/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1269(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1270/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1270(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1271/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1271(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1272/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1272(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1273/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1273(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1274/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1274(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1275/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1275(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1276/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1276(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1277/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1277(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1278/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1278(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1279/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1279(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1280/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1280(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1281/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1281(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1282/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1282(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1283/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1283(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1284/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1284(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1285/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1285(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1286/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1286(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1287/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1287(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1288/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1288(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1289/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1289(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1290/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1290(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1291/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1291(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1292/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1292(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1293/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1293(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1294/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1294(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1295/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1295(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1296/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1296(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1297/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1297(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1298/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1298(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1299/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1299(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1300/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1300(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1301/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1301(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1302/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1302(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1303/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1303(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1304/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1304(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1305/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1305(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1306/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1306(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1307/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1307(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1308/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1308(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1309/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1309(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1310/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1310(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1311/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1311(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1312/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1312(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1313/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1313(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1314/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1314(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1315/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1315(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1316/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1316(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1317/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1317(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1318/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1318(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1319/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1319(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1320/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1320(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1321/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1321(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1322/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1322(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1323/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1323(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1324/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1324(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1325/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1325(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1326/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1326(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1327/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1327(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1328/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1328(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1329/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1329(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1330/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1330(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1331/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1331(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1332/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1332(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1333/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1333(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1334/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1334(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1335/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1335(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1336/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1336(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1337/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1337(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1338/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1338(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1339/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1339(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1340/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1340(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1341/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1341(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1342/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1342(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1343/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1343(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1344/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1344(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1345/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1345(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1346/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1346(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1347/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1347(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1348/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1348(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1349/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1349(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1350/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1350(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1351/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1351(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1352/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1352(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1353/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1353(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1354/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1354(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1355/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1355(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1356/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1356(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1357/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1357(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1358/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1358(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1359/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1359(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1360/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1360(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1361/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1361(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1362/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1362(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1363/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1363(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1364/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1364(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1365/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1365(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1366/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1366(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1367/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1367(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1368/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1368(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1369/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1369(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1370/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1370(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1371/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1371(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1372/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1372(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1373/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1373(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1374/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1374(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1375/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1375(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1376/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1376(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1377/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1377(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1378/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1378(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1379/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1379(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1380/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1380(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1381/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1381(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1382/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1382(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1383/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1383(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1384/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1384(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1385/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1385(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1386/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1386(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1387/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1387(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1388/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1388(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1389/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1389(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1390/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1390(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1391/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1391(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1392/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1392(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1393/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1393(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1394/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1394(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1395/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1395(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1396/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1396(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1397/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1397(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1398/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1398(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1399/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1399(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1400/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1400(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1401/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1401(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1402/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1402(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1403/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1403(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1404/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1404(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1405/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1405(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1406/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1406(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1407/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1407(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1408/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1408(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1409/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1409(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1410/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1410(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1411/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1411(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1412/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1412(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1413/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1413(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1414/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1414(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1415/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1415(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1416/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1416(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1417/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1417(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1418/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1418(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1419/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1419(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1420/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1420(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1421/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1421(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1422/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1422(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1423/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1423(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1424/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1424(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1425/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1425(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1426/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1426(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1427/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1427(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1428/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1428(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1429/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1429(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1430/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1430(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1431/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1431(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1432/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1432(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1433/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1433(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1434/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1434(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1435/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1435(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1436/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1436(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1437/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1437(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1438/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1438(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1439/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1439(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1440/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1440(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1441/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1441(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1442/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1442(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1443/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1443(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1444/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1444(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1445/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1445(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1446/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1446(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1447/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1447(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1448/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1448(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1449/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1449(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1450/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1450(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1451/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1451(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1452/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1452(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1453/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1453(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1454/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1454(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1455/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1455(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1456/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1456(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1457/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1457(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1458/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1458(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1459/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1459(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1460/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1460(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1461/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1461(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1462/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1462(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1463/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1463(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1464/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1464(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1465/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1465(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1466/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1466(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1467/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1467(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1468/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1468(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1469/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1469(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1470/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1470(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1471/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1471(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1472/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1472(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1473/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1473(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1474/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1474(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1475/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1475(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1476/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1476(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1477/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1477(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1478/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1478(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1479/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1479(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1480/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1480(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1481/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1481(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1482/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1482(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1483/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1483(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1484/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1484(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1485/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1485(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1486/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1486(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1487/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1487(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1488/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1488(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1489/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1489(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1490/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1490(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1491/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1491(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1492/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1492(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1493/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1493(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1494/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1494(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1495/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1495(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1496/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1496(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1497/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1497(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1498/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1498(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1499/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1499(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1500/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1500(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1501/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1501(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1502/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1502(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1503/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1503(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1504/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1504(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1505/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1505(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1506/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1506(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1507/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1507(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1508/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1508(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1509/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1509(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1510/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1510(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1511/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1511(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1512/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1512(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1513/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1513(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1514/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1514(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1515/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1515(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1516/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1516(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1517/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1517(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1518/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1518(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1519/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1519(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1520/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1520(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1521/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1521(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1522/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1522(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1523/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1523(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1524/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1524(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1525/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1525(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1526/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1526(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1527/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1527(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1528/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1528(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1529/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1529(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1530/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1530(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1531/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1531(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1532/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1532(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1533/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1533(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1534/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1534(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1535/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1535(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1536/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1536(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1537/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1537(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1538/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1538(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1539/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1539(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1540/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1540(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1541/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1541(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1542/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1542(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1543/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1543(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1544/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1544(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1545/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1545(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1546/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1546(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1547/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1547(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1548/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1548(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1549/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1549(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1550/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1550(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1551/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1551(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1552/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1552(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1553/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1553(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1554/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1554(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1555/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1555(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1556/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1556(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1557/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1557(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1558/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1558(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1559/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1559(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1560/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1560(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1561/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1561(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1562/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1562(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1563/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1563(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1564/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1564(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1565/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1565(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1566/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1566(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1567/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1567(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1568/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1568(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1569/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1569(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1570/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1570(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1571/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1571(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1572/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1572(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1573/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1573(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1574/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1574(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1575/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1575(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1576/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1576(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1577/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1577(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1578/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1578(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1579/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1579(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1580/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1580(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1581/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1581(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1582/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1582(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1583/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1583(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1584/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1584(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1585/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1585(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1586/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1586(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1587/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1587(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1588/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1588(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1589/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1589(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1590/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1590(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1591/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1591(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1592/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1592(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1593/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1593(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1594/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1594(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1595/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1595(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1596/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1596(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1597/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1597(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1598/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1598(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1599/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1599(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1600/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1600(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1601/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1601(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1602/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1602(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1603/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1603(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1604/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1604(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1605/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1605(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1606/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1606(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1607/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1607(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1608/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1608(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1609/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1609(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1610/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1610(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1611/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1611(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1612/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1612(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1613/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1613(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1614/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1614(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1615/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1615(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1616/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1616(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1617/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1617(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1618/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1618(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1619/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1619(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1620/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1620(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1621/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1621(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1622/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1622(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1623/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1623(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1624/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1624(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1625/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1625(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1626/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1626(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1627/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1627(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1628/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1628(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1629/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1629(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1630/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1630(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1631/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1631(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1632/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1632(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1633/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1633(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1634/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1634(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1635/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1635(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1636/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1636(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1637/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1637(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1638/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1638(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1639/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1639(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1640/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1640(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1641/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1641(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1642/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1642(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1643/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1643(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1644/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1644(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1645/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1645(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1646/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1646(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1647/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1647(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1648/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1648(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1649/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1649(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1650/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1650(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1651/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1651(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1652/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1652(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1653/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1653(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1654/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1654(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1655/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1655(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1656/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1656(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1657/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1657(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1658/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1658(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1659/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1659(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1660/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1660(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1661/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1661(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1662/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1662(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1663/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1663(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1664/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1664(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1665/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1665(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1666/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1666(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1667/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1667(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1668/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1668(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1669/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1669(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1670/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1670(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1671/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1671(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1672/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1672(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1673/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1673(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1674/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1674(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1675/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1675(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1676/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1676(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1677/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1677(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1678/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1678(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1679/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1679(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1680/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1680(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1681/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1681(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1682/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1682(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1683/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1683(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1684/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1684(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1685/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1685(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1686/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1686(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1687/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1687(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1688/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1688(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1689/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1689(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1690/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1690(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1691/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1691(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1692/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1692(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1693/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1693(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1694/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1694(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1695/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1695(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1696/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1696(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1697/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1697(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1698/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1698(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1699/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1699(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1700/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1700(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1701/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1701(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1702/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1702(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1703/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1703(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1704/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1704(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1705/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1705(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1706/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1706(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1707/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1707(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1708/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1708(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1709/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1709(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1710/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1710(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1711/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1711(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1712/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1712(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1713/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1713(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1714/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1714(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1715/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1715(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1716/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1716(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1717/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1717(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1718/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1718(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1719/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1719(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1720/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1720(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1721/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1721(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1722/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1722(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1723/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1723(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1724/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1724(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1725/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1725(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1726/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1726(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1727/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1727(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1728/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1728(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1729/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1729(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1730/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1730(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1731/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1731(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1732/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1732(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1733/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1733(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1734/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1734(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1735/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1735(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1736/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1736(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1737/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1737(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1738/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1738(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1739/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1739(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1740/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1740(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1741/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1741(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1742/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1742(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1743/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1743(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1744/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1744(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1745/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1745(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1746/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1746(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1747/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1747(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1748/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1748(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1749/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1749(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1750/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1750(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1751/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1751(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1752/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1752(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1753/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1753(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1754/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1754(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1755/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1755(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1756/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1756(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1757/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1757(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1758/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1758(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1759/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1759(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1760/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1760(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1761/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1761(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1762/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1762(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1763/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1763(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1764/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1764(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1765/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1765(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1766/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1766(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1767/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1767(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1768/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1768(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1769/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1769(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1770/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1770(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1771/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1771(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1772/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1772(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1773/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1773(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1774/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1774(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1775/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1775(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1776/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1776(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1777/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1777(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1778/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1778(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1779/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1779(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1780/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1780(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1781/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1781(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1782/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1782(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1783/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1783(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1784/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1784(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1785/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1785(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1786/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1786(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1787/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1787(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1788/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1788(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1789/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1789(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1790/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1790(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1791/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1791(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1792/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1792(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1793/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1793(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1794/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1794(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1795/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1795(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1796/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1796(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1797/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1797(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1798/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1798(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1799/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1799(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1800/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1800(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1801/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1801(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1802/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1802(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1803/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1803(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1804/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1804(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1805/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1805(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1806/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1806(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1807/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1807(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1808/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1808(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1809/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1809(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1810/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1810(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1811/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1811(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1812/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1812(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1813/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1813(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1814/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1814(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1815/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1815(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1816/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1816(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1817/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1817(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1818/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1818(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1819/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1819(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1820/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1820(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1821/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1821(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1822/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1822(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1823/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1823(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1824/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1824(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1825/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1825(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1826/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1826(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1827/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1827(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1828/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1828(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1829/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1829(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1830/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1830(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1831/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1831(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1832/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1832(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1833/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1833(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1834/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1834(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1835/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1835(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1836/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1836(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1837/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1837(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1838/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1838(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1839/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1839(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1840/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1840(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1841/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1841(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1842/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1842(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1843/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1843(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1844/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1844(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1845/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1845(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1846/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1846(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1847/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1847(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1848/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1848(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1849/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1849(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1850/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1850(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1851/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1851(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1852/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1852(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1853/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1853(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1854/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1854(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1855/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1855(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1856/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1856(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1857/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1857(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1858/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1858(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1859/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1859(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1860/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1860(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1861/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1861(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1862/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1862(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1863/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1863(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1864/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1864(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1865/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1865(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1866/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1866(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1867/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1867(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1868/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1868(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1869/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1869(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1870/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1870(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1871/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1871(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1872/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1872(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1873/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1873(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1874/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1874(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1875/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1875(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1876/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1876(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1877/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1877(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1878/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1878(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1879/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1879(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1880/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1880(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1881/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1881(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1882/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1882(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1883/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1883(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1884/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1884(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1885/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1885(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1886/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1886(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1887/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1887(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1888/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1888(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1889/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1889(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1890/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1890(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1891/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1891(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1892/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1892(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1893/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1893(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1894/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1894(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1895/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1895(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1896/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1896(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1897/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1897(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1898/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1898(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1899/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1899(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1900/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1900(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1901/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1901(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1902/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1902(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1903/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1903(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1904/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1904(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1905/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1905(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1906/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1906(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1907/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1907(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1908/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1908(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1909/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1909(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1910/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1910(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1911/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1911(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1912/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1912(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1913/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1913(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1914/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1914(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1915/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1915(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1916/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1916(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1917/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1917(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1918/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1918(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1919/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1919(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1920/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1920(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1921/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1921(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1922/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1922(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1923/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1923(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1924/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1924(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1925/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1925(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1926/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1926(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1927/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1927(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1928/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1928(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1929/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1929(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1930/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1930(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1931/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1931(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1932/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1932(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1933/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1933(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1934/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1934(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1935/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1935(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1936/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1936(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1937/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1937(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1938/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1938(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1939/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1939(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1940/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1940(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1941/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1941(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1942/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1942(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1943/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1943(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1944/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1944(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1945/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1945(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1946/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1946(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1947/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1947(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1948/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1948(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1949/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1949(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1950/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1950(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1951/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1951(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1952/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1952(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1953/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1953(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1954/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1954(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1955/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1955(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1956/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1956(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1957/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1957(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1958/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1958(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1959/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1959(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1960/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1960(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1961/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1961(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1962/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1962(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1963/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1963(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1964/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1964(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1965/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1965(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1966/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1966(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1967/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1967(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1968/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1968(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1969/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1969(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1970/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1970(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1971/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1971(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1972/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1972(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1973/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1973(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1974/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1974(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1975/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1975(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1976/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1976(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1977/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1977(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1978/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1978(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1979/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1979(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1980/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1980(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1981/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1981(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1982/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1982(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1983/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1983(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1984/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1984(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1985/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1985(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1986/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1986(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1987/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1987(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1988/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1988(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1989/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1989(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1990/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1990(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1991/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1991(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1992/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1992(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1993/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1993(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1994/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1994(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1995/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1995(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1996/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1996(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1997/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1997(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1998/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1998(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink1999/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod1999(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + @DeepLink(value = ["dld://methodDeepLink2000/{param1}"], activityClassFqn = "com.airbnb.deeplinkdispatch.sample.benchmarkable.ScaleTestActivity") + @JvmStatic + fun intentForDeepLinkMethod2000(context: Context): Intent = + Intent(context, ScaleTestActivity::class.java).setAction(ACTION_DEEP_LINK_METHOD) + + } +} diff --git a/sample/build.gradle b/sample/build.gradle index fa39d648..5d887317 100644 --- a/sample/build.gradle +++ b/sample/build.gradle @@ -18,7 +18,8 @@ android { defaultConfig { applicationId "com.airbnb.deeplinkdispatch.sample" - minSdk = androidConfig.minSdkVersion + // Sample app uses minSdk 21 because the test dependency (androidx.test:core) requires it + minSdk = 21 targetSdk = androidConfig.compileSdkVersion versionCode 1 versionName "1.0" @@ -41,6 +42,12 @@ android { lint { disable 'InvalidPackage' } + testOptions { + unitTests { + // Required for Robolectric to access assets from the merged debug assets + includeAndroidResources = true + } + } } dependencies { @@ -70,3 +77,43 @@ ksp { + "com.airbnb.deeplinkdispatch.sample.ksplibrary.ManifestGenWebDeepLink" ) } + +// Copy KSP library assets to main assets for Robolectric tests. +// This is needed because Robolectric doesn't automatically merge assets from library dependencies +// during unit testing (only during instrumentation tests and actual APK builds). +// The assets are copied to the main assets source set so Robolectric can find them. +// +// We also need to copy assets from sample-benchmarkable-library since it now uses KSP with +// asset-based match index. +android.sourceSets.debug { + assets.srcDirs += layout.buildDirectory.dir('generated/libraryAssets') +} + +// The producer task (`mergeDeepLinkAssetsDebug`) is registered inside the other project's +// AGP `onVariants { }` callback, which fires during `projectsEvaluated` — after both +// `afterEvaluate` and `evaluationDependsOn` have run. Defer wiring until then. +gradle.projectsEvaluated { + def copyTask = tasks.register('copyLibraryAssetsForTest', Copy) { + from project(':sample-ksp-library').layout.buildDirectory.dir('intermediates/assets/debug/mergeDeepLinkAssetsDebug') + from project(':sample-benchmarkable-library').layout.buildDirectory.dir('intermediates/assets/debug/mergeDeepLinkAssetsDebug') + into layout.buildDirectory.dir('generated/libraryAssets') + dependsOn project(':sample-ksp-library').tasks.named('mergeDeepLinkAssetsDebug') + dependsOn project(':sample-benchmarkable-library').tasks.named('mergeDeepLinkAssetsDebug') + } + + // Debug-specific tasks that consume these assets. Match by exact name to avoid depending on + // unrelated tasks (e.g. lintVitalRelease) that happen to contain "lint" and "debug". + def consumerTaskNames = [ + 'testDebugUnitTest', + 'mergeDebugAssets', + 'lintDebug', + 'lintAnalyzeDebug', + 'generateDebugLintModel', + 'generateDebugUnitTestLintModel', + 'lintAnalyzeDebugUnitTest', + 'lintReportDebug', + ] as Set + tasks.matching { it.name in consumerTaskNames }.configureEach { + dependsOn(copyTask) + } +} diff --git a/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/DeepLinkActivity.java b/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/DeepLinkActivity.java index 6844db27..b6557ee7 100644 --- a/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/DeepLinkActivity.java +++ b/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/DeepLinkActivity.java @@ -28,12 +28,16 @@ protected void onCreate(Bundle savedInstanceState) { configurablePlaceholdersMap.put("configurable-path-segment", ""); configurablePlaceholdersMap.put("configurable-path-segment-two", ""); configurablePlaceholdersMap.put("configPathOne", "/somePathOne"); + // KSP library modules with the manifest-generation plugin (KspLibraryDeepLinkModuleRegistry) + // require AssetManager to load the binary match index from assets. + // Application modules (SampleModuleRegistry) and KAPT-generated registries + // use the legacy string-based approach and don't need AssetManager. DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( new SampleModuleRegistry(), new LibraryDeepLinkModuleRegistry(), - new BenchmarkDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(getAssets()), new KaptLibraryDeepLinkModuleRegistry(), - new KspLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(getAssets()), configurablePlaceholdersMap ); deepLinkDelegate.dispatchFrom(this); diff --git a/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/typeconversion/TypeConversionErrorHandlerCustomTypeDeepLinkActivity.java b/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/typeconversion/TypeConversionErrorHandlerCustomTypeDeepLinkActivity.java index 30998bbb..fbc19c6a 100644 --- a/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/typeconversion/TypeConversionErrorHandlerCustomTypeDeepLinkActivity.java +++ b/sample/src/main/java/com/airbnb/deeplinkdispatch/sample/typeconversion/TypeConversionErrorHandlerCustomTypeDeepLinkActivity.java @@ -74,12 +74,13 @@ protected void onCreate(Bundle savedInstanceState) { configurablePlaceholdersMap.put("configurable-path-segment", ""); configurablePlaceholdersMap.put("configurable-path-segment-two", ""); configurablePlaceholdersMap.put("configPathOne", "/somePathOne"); + // KSP library modules with manifest-generation plugin require AssetManager to load binary match index DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( new SampleModuleRegistry(), new LibraryDeepLinkModuleRegistry(), - new BenchmarkDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(getAssets()), new KaptLibraryDeepLinkModuleRegistry(), - new KspLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(getAssets()), configurablePlaceholdersMap, typeConvertersLambda, typeConversionErrorNullable, diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AppDeepLinkDelegateTest.kt b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AppDeepLinkDelegateTest.kt index a5274a36..4563b52c 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AppDeepLinkDelegateTest.kt +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AppDeepLinkDelegateTest.kt @@ -16,9 +16,10 @@ import org.hamcrest.core.IsEqual import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment import org.robolectric.annotation.Config -@Config(sdk = [21], manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = [21]) @RunWith(RobolectricTestRunner::class) class AppDeepLinkDelegateTest { // Demo test to find duplicate URLs across all modules @@ -36,9 +37,9 @@ class AppDeepLinkDelegateTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePlaceholdersMap, ) // The duplicate detection finds: diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AutoGenIntentFiltersTest.java b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AutoGenIntentFiltersTest.java index d96fea21..93724a78 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AutoGenIntentFiltersTest.java +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/AutoGenIntentFiltersTest.java @@ -31,7 +31,7 @@ import java.util.HashMap; import java.util.Map; -@Config(sdk = 21, manifest = "../sample/src/main/AndroidManifest.xml", shadows = {ShadowTaskStackBuilder.class}) +@Config(sdk = 21, shadows = {ShadowTaskStackBuilder.class}) @RunWith(RobolectricTestRunner.class) public class AutoGenIntentFiltersTest { diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/ConfigurablePathSegmentTest.kt b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/ConfigurablePathSegmentTest.kt index 3d35cbfd..44b59f0c 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/ConfigurablePathSegmentTest.kt +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/ConfigurablePathSegmentTest.kt @@ -9,9 +9,10 @@ import org.hamcrest.core.IsEqual.equalTo import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment import org.robolectric.annotation.Config -@Config(sdk = [21], manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = [21]) @RunWith(RobolectricTestRunner::class) class ConfigurablePathSegmentTest { private val configurablePathSegmentReplacementsAllEmpty = @@ -48,9 +49,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsAllEmpty, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/nothing-special") @@ -64,9 +65,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementFirstSet, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/cereal/foo") @@ -79,9 +80,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsAllEmpty, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/bar?q=e") @@ -94,9 +95,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsAllEmpty, ) val somePathElementBefore = deepLinkDelegate.supportsUri("https://www.example.com/somevalue/bar/?q=e") @@ -111,9 +112,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsAllEmpty, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/foo?q=e") @@ -126,9 +127,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsOneEmpty, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/bar/foo?q=e") @@ -141,9 +142,9 @@ class ConfigurablePathSegmentTest { DeepLinkDelegate( SampleModuleRegistry(), LibraryDeepLinkModuleRegistry(), - BenchmarkDeepLinkModuleRegistry(), + BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), KaptLibraryDeepLinkModuleRegistry(), - KspLibraryDeepLinkModuleRegistry(), + KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().assets), configurablePathSegmentReplacementsTwoEmpty, ) val oneEmptyReplacementMatches = deepLinkDelegate.supportsUri("https://www.example.com/bar/foo?q=e") diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/CustomPrefixesActivityTest.java b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/CustomPrefixesActivityTest.java index 5e3ba96d..908e066a 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/CustomPrefixesActivityTest.java +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/CustomPrefixesActivityTest.java @@ -23,7 +23,7 @@ import static org.hamcrest.core.IsEqual.equalTo; import static org.robolectric.Shadows.shadowOf; -@Config(sdk = 21, manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = 21) @RunWith(RobolectricTestRunner.class) public class CustomPrefixesActivityTest { @Test public void testAppDeepLinkIntent() { diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTest.kt b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTest.kt index cb590b2c..7fe4d0a6 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTest.kt +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTest.kt @@ -21,7 +21,7 @@ import org.robolectric.RobolectricTestRunner import org.robolectric.Shadows import org.robolectric.annotation.Config -@Config(sdk = [21], manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = [21]) @RunWith(RobolectricTestRunner::class) class DeepLinkHandlerTest { @Test diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTypeConversionTest.kt b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTypeConversionTest.kt index 09233582..b44c2a36 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTypeConversionTest.kt +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/DeepLinkHandlerTypeConversionTest.kt @@ -19,7 +19,7 @@ import org.robolectric.Shadows.shadowOf import org.robolectric.annotation.Config import java.lang.NumberFormatException -@Config(sdk = [21], manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = [21]) @RunWith(RobolectricTestRunner::class) class DeepLinkHandlerTypeConversionTest { @Test diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/MainActivityTest.java b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/MainActivityTest.java index b396eb1f..8a0cb76d 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/MainActivityTest.java +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/MainActivityTest.java @@ -7,10 +7,10 @@ import com.airbnb.deeplinkdispatch.DeepLink; import com.airbnb.deeplinkdispatch.DeepLinkDispatch; import com.airbnb.deeplinkdispatch.sample.benchmarkable.BenchmarkDeepLinkModuleRegistry; +import com.airbnb.deeplinkdispatch.sample.kaptlibrary.KaptLibraryDeepLinkModuleRegistry; import com.airbnb.deeplinkdispatch.sample.ksplibrary.KspLibraryDeepLinkModuleRegistry; import com.airbnb.deeplinkdispatch.sample.library.LibraryActivity; import com.airbnb.deeplinkdispatch.sample.library.LibraryDeepLinkModuleRegistry; -import com.airbnb.deeplinkdispatch.sample.kaptlibrary.KaptLibraryDeepLinkModuleRegistry; import org.junit.Test; import org.junit.runner.RunWith; @@ -33,7 +33,7 @@ import androidx.core.app.TaskStackBuilder; -@Config(sdk = 21, manifest = "../sample/src/main/AndroidManifest.xml", shadows = {ShadowTaskStackBuilder.class}) +@Config(sdk = 21, shadows = {ShadowTaskStackBuilder.class}) @RunWith(RobolectricTestRunner.class) public class MainActivityTest { @Test @@ -297,8 +297,13 @@ public void testSupportsUri() throws Exception { configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); configurablePathSegmentReplacements.put("configurable-path-segment-one", "/belong"); configurablePathSegmentReplacements.put("configurable-path-segment-two", "/anywhere"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); assertThat(deepLinkDelegate.supportsUri("dld://classDeepLink"), equalTo(true)); assertThat(deepLinkDelegate.supportsUri("some://weirdNonExistentUri"), equalTo(false)); } @@ -309,8 +314,13 @@ public void testSameLengthComponentsMismatch() throws Exception { configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); configurablePathSegmentReplacements.put("configurable-path-segment-one", "/belong"); configurablePathSegmentReplacements.put("configurable-path-segment-two", "/anywhere"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); assertThat(deepLinkDelegate.supportsUri("dld://classDeepLink"), equalTo(true)); assertThat(deepLinkDelegate.supportsUri("dld://classDeepLinx"), equalTo(false)); } @@ -321,8 +331,13 @@ public void testConfigurablePathSegmentMatch() { configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); configurablePathSegmentReplacements.put("configurable-path-segment-one", "/belong"); configurablePathSegmentReplacements.put("configurable-path-segment-two", "/anywhere"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); assertThat(deepLinkDelegate.supportsUri("https://www.example.com/capnMcCains/bar"), equalTo(false)); assertThat(deepLinkDelegate.supportsUri("https://www.example.com/obamaOs/bar"), equalTo(true)); } @@ -334,8 +349,13 @@ public void testMissingKeysThrowsIAException() { try { Map configurablePathSegmentReplacements = new HashMap<>(); configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); } catch (IllegalArgumentException e) { message = e.getMessage(); } @@ -354,8 +374,13 @@ public void testPathSegmentUriNoMatch() { configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); configurablePathSegmentReplacements.put("configurable-path-segment-one", "/belong"); configurablePathSegmentReplacements.put("configurable-path-segment-two", "/anywhere"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); assertThat(deepLinkDelegate.supportsUri("https://www.example.com//bar"), equalTo(false)); assertThat(deepLinkDelegate.supportsUri("https://www.example.com//bar"), equalTo(false)); } @@ -366,8 +391,13 @@ public void testTwoConfigurablePathSegmentsMatch() { configurablePathSegmentReplacements.put("configurable-path-segment", "/obamaOs"); configurablePathSegmentReplacements.put("configurable-path-segment-one", "/belong"); configurablePathSegmentReplacements.put("configurable-path-segment-two", "/anywhere"); - DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate(new SampleModuleRegistry(), - new LibraryDeepLinkModuleRegistry(), new BenchmarkDeepLinkModuleRegistry(), new KaptLibraryDeepLinkModuleRegistry(), new KspLibraryDeepLinkModuleRegistry(), configurablePathSegmentReplacements); + DeepLinkDelegate deepLinkDelegate = new DeepLinkDelegate( + new SampleModuleRegistry(), + new LibraryDeepLinkModuleRegistry(), + new BenchmarkDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + new KaptLibraryDeepLinkModuleRegistry(), + new KspLibraryDeepLinkModuleRegistry(RuntimeEnvironment.getApplication().getAssets()), + configurablePathSegmentReplacements); assertThat(deepLinkDelegate.supportsUri("https://www.example.com/anywhere/belong/foo"), equalTo(false)); assertThat(deepLinkDelegate.supportsUri("https://www.example.com/belong/anywhere/foo"), equalTo(true)); } diff --git a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/SecondActivityTest.java b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/SecondActivityTest.java index b9b1b88c..72b2fb87 100644 --- a/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/SecondActivityTest.java +++ b/sample/src/test/java/com/airbnb/deeplinkdispatch/sample/SecondActivityTest.java @@ -17,7 +17,7 @@ import static org.hamcrest.core.IsEqual.equalTo; import static org.robolectric.Shadows.shadowOf; -@Config(sdk = 21, manifest = "../sample/src/main/AndroidManifest.xml") +@Config(sdk = 21) @RunWith(RobolectricTestRunner.class) public class SecondActivityTest { @Test public void testIntent() {