}
        break;
      }
      case ::tensorflow::AttrValue::kI:
        flex_builder->Int(key, attr.i());
        break;
      case ::tensorflow::AttrValue::kF:
        flex_builder->Float(key, attr.f());
        break;
      case ::tensorflow::AttrValue::kB:
        flex_builder->Bool(key, attr.b());
        break;
      case tensorflow::AttrValue::kList:

   * only become known via CAS failures, convergence can be slow,
   * and because threads are typically not bound to CPUS forever,
   * may not occur at all. However, despite these limitations,
   * observed contention rates are typically low in these cases.
   *
   * It is possible for a Cell to become unused when threads that
   * once hashed to it terminate, as well as in the case where

  std::vector<std::string> quantization_attributes;
  switch (op_type) {
    case OpType::kDynamicRangeOp:
      quantization_attributes = {"rhs_quantization"};
      break;
    case OpType::kUnaryOp:
      quantization_attributes = {"quantization"};
      break;
    case OpType::kBinaryOp:
      quantization_attributes = {"lhs_quantization", "rhs_quantization",

    if (std::get<0>(res_it) != std::get<1>(res_it)) return std::nullopt;

  // There can only be non-truncating cast op's prior to the call.
  for (; it != block.rend(); ++it) {
    CastOp cast = dyn_cast<CastOp>(*it);
    if (!cast || cast.getTruncate()) return std::nullopt;
  }

  return call;
}

using ArgMatcherFn = function_ref<bool(Value, Region&, Value, Region&)>;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.provider;

import org.gradle.internal.Cast;
import org.gradle.internal.UncheckedException;

import javax.annotation.Nullable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.concurrent.Callable;

/**

class TFL_AnyStrAttrOf<list<string> cases> : StringBasedAttr<
  CPred<!foldl(
      "$_self.cast<StringAttr>().getValue() == \"" # !head(cases) # "\"",
      !foreach(case, !tail(cases),
               "$_self.cast<StringAttr>().getValue() == \"" # case # "\""),
      prev, cur, prev # " || " # cur)>,
  "string attribute whose value is " #
    !foldl(/*init*/!head(cases), /*list*/!tail(cases),

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.Cast;

import java.util.HashMap;
import java.util.Map;

/**
 * This in-memory cache is responsible for caching compiled build scripts during a build.
 * If the compiled script is not found in this cache, it will try to find it in the global cache,
 * which will use the delegate script class compiler in case of a miss. The lookup in this cache is

	funcName := e.getFunctionName()

	switch funcName {
	case sqlFnCast:
		return e.Cast.Expr.analyze(s)

	case sqlFnExtract:
		return e.Extract.From.analyze(s)

	case sqlFnDateAdd:
		result.combine(e.DateAdd.Quantity.analyze(s))
		result.combine(e.DateAdd.Timestamp.analyze(s))
		return result

	case sqlFnDateDiff:
		result.combine(e.DateDiff.Timestamp1.analyze(s))

    /**
     * Attribute matching can be very expensive. In case there are multiple candidates, we
     * cache the result of the query, because it's often the case that we ask for the same
     * disambiguation of attributes several times in a row (but with different candidates).
     */
    private final ConcurrentMap<CachedQuery, int[]> cachedQueries = new ConcurrentHashMap<>();

   // 2. The einsum is not created by the convert function itself.
   // 3. Both inputs are int32 tensor.
   // 4. Both inputs have the graph ancestor of either const-(sub), or cast-sub.
   // 5. The type of the const tensor (or input of the cast operation) is int8.
   (IsEinsumOpSupported $einsum, $args, $equation)],