for (auto& use : uses_optional.value()) {
    if (llvm::isa<TF::WhileOp>(use.getUser())) {
      if (while_op != nullptr) {
        use.getUser()->emitOpError() << "multiple users of function.";
        return LogicalResult::failure();
      } else {
        while_op = llvm::cast<TF::WhileOp>(use.getUser());
      }
    } else {
      use.getUser()->emitOpError() << "non while use of function.";
      return LogicalResult::failure();

      has_dynamic_output = true;
      for (Operation* user : v.getUsers()) {
        if (!HasOutsideCompilationAncestor(user) &&
            !llvm::isa<mlir::tf_device::ReturnOp>(user))
          return true;
      }
    }
    if (!tensorflow::TypeValidForXLA(v.getType()))
      for (const Operation* user : v.getUsers())
        if (!llvm::isa<mlir::tf_device::ReturnOp>(user))

      TF::PartitionedCallOp call_op, const SmallVector<Value, 4>& args,
      PatternRewriter& rewriter) const {
    bool followed_by_dequantize = false;
    for (Operation* user : call_op->getUsers()) {
      if (llvm::isa<quantfork::DequantizeCastOp>(user)) {
        followed_by_dequantize = true;
        break;
      }
    }
    if (!followed_by_dequantize) return success();

    if (!target_attr) target_attr = rewriter.getBoolAttr(false);
    narrow_range = target_attr;
  }
  {
    for (auto user : fakequant_op->getResult(0).getUsers()) {
      if (!absl::c_linear_search(target_ops, user)) {
        return rewriter.notifyMatchFailure(op, [&](Diagnostic &diag) {
          diag << "Skipping reordering between FakeQuant and "

   (IsPrefixTruncatedShapeEqualTo $input, $second_transpose)]>;

class AllUsersAreAddOpsAndCanFuseWith<string op_to_fuse_with> : Constraint<CPred<
  "llvm::all_of($0.getUsers(), [&](Operation *user) {"
  "  if(!llvm::isa<TFL::AddOp>(user)) return false;"
  "  if(!user->getOperand(0).getDefiningOp<"#op_to_fuse_with#">()) return false;"
  "  return true;"

				}(),
				MemberOf: cache.iamUserGroupMemberships[k].ToSlice(),
			}
		}
	}

	return result, nil
}

// GetUsers - returns all users (not STS or service accounts).
func (store *IAMStoreSys) GetUsers() map[string]madmin.UserInfo {
	cache := store.rlock()
	defer store.runlock()

	result := map[string]madmin.UserInfo{}
	for k, u := range cache.iamUsersMap {

    ResourceArgUseInfo info;
    info.used = false;
    info.updated = false;
    bool read_or_assigned = false;
    bool used_in_unsupported_op = false;
    for (auto user : arg.getUsers()) {
      if (user == return_op) continue;
      info.used = true;
      if (auto read = llvm::dyn_cast<TF::ReadVariableOp>(user)) {
        read_or_assigned = true;
        info.data_type = read.getType();

	case <-sys.configLoaded:
	default:
		err = sys.store.LoadUser(ctx, accessKey)
		loadUserCalled = true
	}

	u, ok = sys.store.GetUser(accessKey)
	if !ok && !loadUserCalled {
		err = sys.store.LoadUser(ctx, accessKey)
		loadUserCalled = true

		u, ok = sys.store.GetUser(accessKey)
	}

	if !ok && loadUserCalled && err != nil {
		iamLogOnceIf(ctx, err, accessKey)

		// return 503 to application

	users := []User{
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),
		*GetUser("find_in_batches_with_offset_limit", Config{}),

            return returnType;
        }
    }

    protected static class PropertyMetadata {
        private final String name;
        private final List<MethodMetadata> getters = new ArrayList<>();
        private final List<MethodMetadata> overridableGetters = new ArrayList<>();
        private final List<Method> overridableSetters = new ArrayList<>();