if !ok {
		return false, nil
	}
	idx := 0
	for {
		lris, ok := l.lockMap[resource]
		if !ok {
			// Inconsistent. Delete UID.
			delete(l.lockUID, formatUUID(args.UID, idx))
			return idx > 0, nil
		}
		now := UTCNow()
		for i := range lris {
			if lris[i].UID == args.UID {
				lris[i].TimeLastRefresh = now.UnixNano()
			}
		}
		idx++
		resource, ok = l.lockUID[formatUUID(args.UID, idx)]

		sort.Slice(expect.Pets, func(i, j int) bool {
			return expect.Pets[i].ID > expect.Pets[j].ID
		})

		for idx, pet := range user.Pets {
			if pet == nil || expect.Pets[idx] == nil {
				t.Errorf("pets#%v should equal, expect: %v, got %v", idx, expect.Pets[idx], pet)
			} else {
				doCheckPet(t, *pet, *expect.Pets[idx], unscoped)
			}
		}
	})

	t.Run("Toys", func(t *testing.T) {

    input_tensors->emplace_back(node, idx);

    const auto& iter = input_nodes->find(node);
    if (iter == input_nodes->end()) {
      input_nodes->insert({node, {idx}});
    } else {
      auto& indices = iter->second;
      if (std::find(indices.begin(), indices.end(), idx) != indices.end()) {
        return InvalidArgument("TF_Output ", node->name(), ":", idx,

					if idx.Comment != "" {
						createTableSQL += fmt.Sprintf(" COMMENT '%s'", idx.Comment)
					}

					if idx.Option != "" {
						createTableSQL += " " + idx.Option
					}

					createTableSQL += ","
					values = append(values, clause.Column{Name: idx.Name}, tx.Migrator().(BuildIndexOptionsInterface).BuildIndexOptions(idx.Fields, stmt))
				}
			}

        final int n =
                this.response.getStatus() == WinError.ERROR_MORE_DATA ? this.response.getNumEntries() - 1 : this.response.getNumEntries();
        while (this.ridx < n) {
            final FileEntry itm = this.response.getResults()[this.ridx];
            this.ridx++;
            if (filter(itm)) {
                return itm;
            }
        }

  {{- range $idx, $policy := .Values.policies }}
  # Policy: {{ $policy.name }}
  policy_{{ $idx }}.json: |-
    {{- include (print $.Template.BasePath "/_helper_policy.tpl") . | nindent 4 }}
  {{ end }}
  {{- range $idx, $svc := .Values.svcaccts }}
  {{- if $svc.policy }}
  # SVC: {{ $svc.accessKey }}
  svc_policy_{{ $idx }}.json: |-

        int idx = 0;
        SMBUtil.writeInt2(minVersion, data, idx);
        idx += 2;
        SMBUtil.writeInt2(maxVersion, data, idx);
        idx += 2;
        SMBUtil.writeInt2(reserved, data, idx);
        idx += 2;
        SMBUtil.writeInt2(creditsRequested, data, idx);
        idx += 2;
        SMBUtil.writeInt4(preferredSendSize, data, idx);
        idx += 4;

        idx += 2;
        SMBUtil.writeInt2(reserved, data, idx);
        idx += 2;
        SMBUtil.writeInt2(creditsGranted, data, idx);
        idx += 2;
        SMBUtil.writeInt2(creditsRequested, data, idx);
        idx += 2;
        SMBUtil.writeInt4(status, data, idx);
        idx += 4;
        SMBUtil.writeInt4(maxReadWriteSize, data, idx);
        idx += 4;

	for idx, client := range sys.peerClients {
		client := client
		g.Go(func() error {
			if client == nil {
				return errPeerOffline
			}
			res, err := client.HealBucket(ctx, bucket, opts)
			if err != nil {
				return err
			}
			healBucketResults[idx] = res
			return nil
		}, idx)
	}

	errs = g.Wait()

	)

	convertParams = func(v interface{}, idx int) {
		switch v := v.(type) {
		case bool:
			vars[idx] = strconv.FormatBool(v)
		case time.Time:
			if v.IsZero() {
				vars[idx] = escaper + tmFmtZero + escaper
			} else {
				vars[idx] = escaper + v.Format(tmFmtWithMS) + escaper
			}
		case *time.Time:
			if v != nil {
				if v.IsZero() {
					vars[idx] = escaper + tmFmtZero + escaper
				} else {