on); public void clear(); public boolean remove(Object); public boolean removeAll(java.util.Collection); public boolean retainAll(java.util.Collection); protected final org.codehaus.plexus.logging.Logger getLogger(); protected final java.util.Set getSet(); protected final java.util.Set checkedGetSet() throws org.codehaus.plexus.component.repository.exception.ComponentLookupExcep; public final String getRole(); protected final void setRole(String); public final void contextualize(org.codehaus.ple...

on); public void clear(); public boolean remove(Object); public boolean removeAll(java.util.Collection); public boolean retainAll(java.util.Collection); protected final org.codehaus.plexus.logging.Logger getLogger(); protected final java.util.Set getSet(); protected final java.util.Set checkedGetSet() throws org.codehaus.plexus.component.repository.exception.ComponentLookupExcep; public final String getRole(); protected final void setRole(String); public final void contextualize(org.codehaus.ple...

  func.walk([&](func::ReturnOp ret) {
    int i = 0;
    for (Value returned : ret.getOperands()) {
      llvm::SmallVector<Value, 4> quantized;
      for (auto user : returned.getUsers()) {
        if (auto q = Quantized(user)) {
          quantized.push_back(q);
        }
      }
      if (quantized.size() == 1) {
        ret.setOperand(i, quantized.front());
      }
      i++;

			},
		},
	}
	for i, tc := range testCases {
		attr := authorizer.AttributesRecord{
			User:      &tc.User,
			Namespace: tc.Namespace,
		}
		resourceRules, nonResourceRules, _, _ := a.RulesFor(attr.GetUser(), attr.GetNamespace())
		actualResourceRules := getResourceRules(resourceRules)
		if !reflect.DeepEqual(tc.ExpectResourceRules, actualResourceRules) {
			t.Logf("tc: %v -> attr %v", tc, attr)

                           op_quant_scale_spec_getter)) {
        redundant_stats_ops.insert(stats_op);
      }
    }

    for (Operation* user : stats_op.getResult().getUsers()) {
      // We don't propagate this parameter down if it has multiple operands.
      // We want to use the result parameter scales instead.
      if (!IsSameScaleOp(user, op_quant_scale_spec_getter) ||

  bool IsQuantized(Operation* op);

  // Adds all the users of index-th result of op to the work list.
  void AddUserToList(Operation* op, const int index) {
    for (Operation* user : op->getResult(index).getUsers()) {
      work_list_.push_back(user);
    }
  }

  // Adds the defining op of index-th operand of op to the work list.
  void AddOperandToList(Operation* op, const int index) {

	}

	if globalIAMSys.LDAPConfig.Enabled() {
		perms, _ := processLDAPAuthentication(key, pass, user)
		if perms != nil {
			return perms, nil
		}
	}

internalAuth:
	ui, ok := globalIAMSys.GetUser(context.Background(), user)
	if !ok {
		return nil, errNoSuchUser
	}

	if caPublicKey != nil {
		err := validateKey(c, key)
		if err != nil {
			return nil, errAuthentication
		}
	} else {

// behavior.
func (w *WebhookAuthorizer) Authorize(ctx context.Context, attr authorizer.Attributes) (decision authorizer.Decision, reason string, err error) {
	r := &authorizationv1.SubjectAccessReview{}
	if user := attr.GetUser(); user != nil {
		r.Spec = authorizationv1.SubjectAccessReviewSpec{
			User:   user.GetName(),
			UID:    user.GetUID(),
			Groups: user.GetGroups(),
			Extra:  convertToSARExtra(user.GetExtra()),
		}
	}

	return fmt.Sprintf("user=(%s), groups=(%s), verb=(%s), resource=(%s), namespace=(%s), apiGroup=(%s)",
		d.user, strings.Split(d.groups, ","), d.verb, d.resource, d.namespace, d.apiGroup)
}

func (d *defaultAttributes) GetUser() user.Info {
	return &user.DefaultInfo{Name: d.user, Groups: strings.Split(d.groups, ",")}
}
func (d *defaultAttributes) GetVerb() string         { return d.verb }

  for (Operation &op : block) {
    if (auto local_var = IsLocalVarOp(op)) {
      local_vars.push_back(local_var.value());
    }
  }
  for (auto local_var : local_vars) {
    auto users = LocalVarOp_resource(local_var).getUsers();
    if (llvm::all_of(users, [](const Operation *user) {
          return isa<TF::AssignVariableOp>(user) ||
                 isa<TF::DestroyResourceOp>(user);
        })) {