import org.gradle.profiler.BuildAction;
import org.gradle.profiler.BuildContext;
import org.gradle.profiler.BuildMutator;
import org.gradle.profiler.GradleBuildConfiguration;
import org.gradle.profiler.InvocationSettings;
import org.gradle.profiler.Logging;
import org.gradle.profiler.ScenarioDefinition;
import org.gradle.profiler.ScenarioInvoker;
import org.gradle.profiler.gradle.DaemonControl;

// RUN: tf-opt "-xla-legalize-tf=device-type=XLA_CPU_JIT legalize-chlo=false use-tf2xla-fallback=true prefer-tf2xla=true" %s | FileCheck %s
// RUN: tf-opt "-xla-legalize-tf=device-type=XLA_CPU_JIT legalize-chlo=false prefer-tf2xla=true" %s | FileCheck --check-prefix NOFALLBACK %s

module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 268 : i32}} {

// CHECK-LABEL: @abs
func.func @abs(%arg0: tensor<2xf32>) -> tensor<2xf32> {

      }));

  TF_RETURN_IF_ERROR(rm->LookupOrCreate<DeviceCompilationProfiler>(
      rm->default_container(), "device_compilation_profiler", profiler,
      [](DeviceCompilationProfiler** profiler) {
        *profiler = new DeviceCompilationProfiler();
        return absl::OkStatus();
      }));

  XlaCompiler::Options options = GenerateCompilerOptions(

                      prefixLen: 32
            - orIds:
                ids:
                - directRemoteIp:
                    addressPrefix: 10.10.10.10
                    prefixLen: 32
            - notId:
                orIds:
                  ids:
                  - directRemoteIp:
                      addressPrefix: 90.10.10.10
                      prefixLen: 32
            - orIds:
                ids:

 *
 * Platform component interfaces and their default implementations are always prefixed with the word `Kotlin`, in contrast to
 * [KaEngineService]s which are prefixed with `Ka`. It is recommended to keep this naming convention in platform implementations. For
 * example, the Standalone API uses a `KotlinStandalone` prefix for its own platform component implementations.
 */
public interface KotlinPlatformComponent

/**

    }

    public ImplementationDependencyRelocator(RuntimeShadedJarType type) {
        prefixes = readPrefixes(type);
    }

    @Override
    public String map(String name) {
        String value = name;

        String prefix = "";

        Matcher m = classPattern.matcher(name);
        if (m.matches()) {
            prefix = m.group(1) + "L";
            name = m.group(2);
        }

	data.VersionIDMarker = versionIDMarker
	data.IsTruncated = resp.IsTruncated

	prefixes := make([]CommonPrefix, 0, len(resp.Prefixes))
	for _, prefix := range resp.Prefixes {
		prefixItem := CommonPrefix{}
		prefixItem.Prefix = s3EncodeName(prefix, encodingType)
		prefixes = append(prefixes, prefixItem)
	}
	data.CommonPrefixes = prefixes
	return data
}

                    prefixLen: 22
            - notId:
                orIds:
                  ids:
                  - remoteIp:
                      addressPrefix: 192.168.244.139
                      prefixLen: 32
            - orIds:
                ids:
                - directRemoteIp:
                    addressPrefix: 1.2.3.4
                    prefixLen: 32
            - notId:

		bitPosition = n.prefix.Bits()
	}

	if n != nil && n.public && n.prefix == prefix {
		last = n
	}

	if last != nil {
		return last.prefix, last.val, true
	}
	var zeroT T
	return netip.Prefix{}, zeroT, false
}

// ShortestPrefixMatch returns the shortest prefix match, the stored value and true if exist.
// For example, considering the following prefixes 192.168.20.16/28 and 192.168.0.0/16,

                    prefixLen: 32
                - destinationIp:
                    addressPrefix: 192.168.10.0
                    prefixLen: 24
            - notRule:
                orRules:
                  rules:
                  - destinationIp:
                      addressPrefix: 90.10.10.10
                      prefixLen: 32
                  - destinationIp: