}
					newTLSSidecarDestinationRule(t, apps.External.All, "MUTUAL", tc.drSelector, tc.credentialToUse,
						tc.from.Config().Namespace)
					callOpt := newTLSSidecarCallOpts(apps.External.All[0], host, tc.expectedResponse)
					tc.from[0].CallOrFail(t, callOpt)
				})
			}
		})
}

// Authorize only specific sidecars in the namespace with secret listing permissions.

      if (!fold_all_constants_flag_) {
        if (!IsConstOrQConstInt(op)) return;
      }

      for (auto consumer : op->getResult(0).getUsers()) {
        auto consumer_call = llvm::dyn_cast_or_null<func::CallOp>(consumer);

        if (!consumer_call) continue;

        auto function_name = consumer_call.getCallee();

        // Locate the argument position of the use.
        int argument_index = -1;

John Howard <******@****.***> 1704863403 -0800

      // values generated elsewhere.
      return all_operations.contains(o.getOwner());
    });
  }

  // Insert function call.
  builder.setInsertionPoint(ops[0]);
  auto call = builder.create<mlir::func::CallOp>(
      ops[0]->getLoc(), func.getFunctionType().getResults(), func.getSymName(),
      inputs);
  for (const auto& v : llvm::enumerate(outputs)) {

    auto caster = make_caster<absl::string_view>();
    // Make sure the user passed a valid python string.
    if (!caster.load(src, convert)) return false;

    const absl::string_view serialized_proto =
        cast_op<absl::string_view>(std::move(caster));

    // NOLINTNEXTLINE: Explicit std::string conversion required for OSS.
    return value.ParseFromString(std::string(serialized_proto));
  }

  // begin[i].
  //
  // If slice_size[i] < -1 then executing the slice will throw an error, and we
  // don't do anything here.  We've already filtered these cases out in
  // IsRewritableSlice.

  if (absl::c_all_of(slice_inputs.size_as_vector,
                     [](int64_t i) { return i >= 0; })) {
    *size = slice_inputs.size;
    return absl::OkStatus();
  }

  Output input_shape =

    storage_.resize(other.storage_.size(), 0);
  }

  for (int i = 0, end = other.storage_.size(); i < end; i++) {
    storage_[i] |= other.storage_[i];
  }
}

bool DeviceSet::IsEmpty() const {
  return absl::c_all_of(storage_, [&](uint64 val) { return val == 0; });
}

absl::StatusOr<DeviceId> DeviceInfoCache::GetIdFor(absl::string_view name) {
  TF_RET_CHECK(!name.empty());

  auto it = name_to_id_.find(name);

  }

  for (auto pair : llvm::zip(new_op.getRegions(), case_op.getRegions())) {
    std::get<0>(pair)->takeBody(*std::get<1>(pair));
  }
  case_op.replaceAllUsesWith(
      new_op.getResults().take_front(case_op.getNumResults()));
  case_op.erase();
  return success();
}

template <typename CallOp>
LogicalResult HandlePartitionedCallOp(
    CallOp call, func::FuncOp callee, ModuleOp module,

  StringRef op_type_with_suffix =
      mlir::cast<NameLoc>(locations.front()).getName().strref();
  if (!op_type_with_suffix.ends_with(":")) return false;

  return absl::c_all_of(locations, [](Location loc) {
    return isa<NameLoc>(loc) ||
           (isa<CallSiteLoc>(loc) &&
            isa<NameLoc>(mlir::cast<CallSiteLoc>(loc).getCallee()));
  });
}

  });

  // Get read only variables by checking if their users only have read effect.
  llvm::DenseSet<ResourceHandle> read_only_vars;
  for (const auto &[resource_handle, var_handle_ops] : resources) {
    if (std::all_of(var_handle_ops.begin(), var_handle_ops.end(),
                    [](Operation *op) {
                      for (auto *user : op->getUsers()) {
                        if (!OnlyHasReadEffect(user)) return false;