#
# 2. RUN ANY OTHER SCRIPT AND ENV WITH NO SIDE EFFECTS (NO UPLOADS)
#    To use:
#       export TFCI=ci/official/envs/env_goes_here
#       export TF_ANY_SCRIPT=ci/official/wheel.sh
#       ./any.sh
#
# 3. DO THE SAME WITH A LOCAL CACHE OR RBE:
#       export TF_ANY_EXTRA_ENV=ci/official/envs/public_cache,ci/official/envs/disk_cache
#       ...
#       ./any.sh
#     or
#       export TF_ANY_EXTRA_ENV=ci/official/envs/local_rbe

                      SavedModel* saved_model_proto);

// Finds and returns the MetaGraphDef (within the provided SavedModel) that
// matches the given set of tags. The lifetime of the returned MetaGraphDef is
// the same as the lifetime of `saved_model_proto`.
//
// FindMetaGraphDef returns a failure status when no MetaGraphDef matches the
// provided tags.
absl::StatusOr<MetaGraphDef*> FindMetaGraphDef(

import org.apache.maven.api.PathType;

/**
 * Cache of {@link PathModularization} instances computed for given {@link Path} elements.
 * The cache is used for avoiding the need to reopen the same files many times when the
 * same dependency is used for different scope. For example a path used for compilation
 * is typically also used for tests.
 */
class PathModularizationCache {
    /**

	// Note: runExistingState is NOT respected here.
	// Informer doesn't expose a way to do that. However, due to the runtime model of informers, this isn't a dealbreaker;
	// the handlers are all called async, so we don't end up with the same deadlocks we would have in the other collection types.
	// While this is quite kludgy, this is an internal interface so its not too bad.
	if !i.eventHandlers.Insert(f) {

     *
     * @param added a collector that represents an addition to the collection to be returned by this supplier
     * @return a new supplier that produces a collection that contains the
     * same elements as this supplier, plus the elements obtained via the given <code>added</code> collector
     */
    CollectionSupplier<T, C> plus(Collector<T> added);

    ExecutionTimeValue<? extends C> calculateExecutionTimeValue();

		case clientfeatures.GA:
			converted.PreRelease = featuregate.GA
		case clientfeatures.Deprecated:
			converted.PreRelease = featuregate.Deprecated
		default:
			// The default case implies programmer error.  The same set of prerelease
			// constants must exist in both component-base and client-go, and each one
			// must have a case here.
			panic(fmt.Sprintf("unrecognized prerelease %q of feature %q", spec.PreRelease, name))
		}

     * See {@code subprojects/core-api/src/main/java/org/gradle/package-info.java} for an example.
     * <p>
     * Note that adding the annotation for a package in one subproject will automatically apply it for the same package in all other subprojects.
     * Therefore, it's advised to add the annotation to the package in the most appropriate subproject.

inline int32_t CalculateBinIndex(const float value, const float lower_bound,
                                 const float bin_width) {
  return std::floor((value - lower_bound) / bin_width);
}

// Same as `CalculateBinIndex` but clamps to avoid out-of-bound.
inline int32_t CalculateBinIndexSafe(const float value, const float lower_bound,
                                     const float bin_width,

    public abstract fun restoreSymbol(analysisSession: KaSession): S?

    /**
     * @return **true** if [other] pointer can be restored to the same symbol. The operation is symmetric and transitive.
     */
    public open fun pointsToTheSameSymbolAs(other: KaSymbolPointer<KaSymbol>): Boolean = this === other

    override fun toString(): String = renderAsDataClassToString()

type U7 interface { M32 /* ERROR "duplicate method" */ ; m() }
type U8 interface { m(); M32 /* ERROR "duplicate method" */ }
type U9 interface { M32; M64 /* ERROR "duplicate method" */ }

// Verify that repeated embedding of the same interface(s)
// eliminates duplicate methods early (rather than at the
// end) to prevent exponential memory and time use.
// Without early elimination, computing T29 may take dozens
// of minutes.
type (