// which uses role:roleHint for identity...and roleHint == goalPrefix:goal.
        // role does not vary for Mojos.
        List<MojoDescriptor> mojos = getMojos();

        if (mojos != null && mojos.contains(mojoDescriptor)) {
            int indexOf = mojos.indexOf(mojoDescriptor);

            existing = mojos.get(indexOf);
        }

        if (existing != null) {

					called = true
					db.AddError(i.BeforeCreate(tx))
				}
			}
			return called
		})
	}
}

// Create create hook
func Create(config *Config) func(db *gorm.DB) {
	supportReturning := utils.Contains(config.CreateClauses, "RETURNING")

	return func(db *gorm.DB) {
		if db.Error != nil {
			return
		}

		if db.Statement.Schema != nil {
			if !db.Statement.Unscoped {

	testCases := []struct {
		bucketName        string
		copySourceHeader  string // data for "X-Amz-Copy-Source" header. Contains the object to be copied in the URL.
		copySourceRange   string // data for "X-Amz-Copy-Source-Range" header, contains the byte range offsets of data to be copied.
		uploadID          string // uploadID of the transaction.
		invalidPartNumber bool   // Sets an invalid multipart.

    KeySet(RegularImmutableMap<K, ?> map) {
      this.map = map;
    }

    @Override
    K get(int index) {
      return map.entries[index].getKey();
    }

    @Override
    public boolean contains(@CheckForNull Object object) {
      return map.containsKey(object);
    }

    @Override
    boolean isPartialView() {
      return true;
    }

    @Override
    public int size() {

pkg net/netip, method (AddrPort) String() string
pkg net/netip, method (Prefix) Addr() Addr
pkg net/netip, method (Prefix) AppendTo([]uint8) []uint8
pkg net/netip, method (Prefix) Bits() int
pkg net/netip, method (Prefix) Contains(Addr) bool
pkg net/netip, method (Prefix) IsSingleIP() bool
pkg net/netip, method (Prefix) IsValid() bool
pkg net/netip, method (Prefix) MarshalBinary() ([]uint8, error)

	i.hits++
	// Log every 5 times to not spam too much (and not log on initial startup where some reconciling is expected
	if i.hits > 5 {
		detectedCNI := ""
		if strings.Contains(i.in.cniConfigFilepath, "cilium") {
			detectedCNI = "cilium"
		}
		hint := ""
		switch detectedCNI {
		case "cilium":

			}
		}

		str := getUserAgent(testCase.mode)
		expectedStr := testCase.expectedStr
		if IsDocker() {
			expectedStr = strings.ReplaceAll(expectedStr, "; source", "; docker; source")
		}
		if !strings.Contains(str, expectedStr) {
			t.Errorf("Test %d: expected: %s, got: %s", i+1, expectedStr, str)
		}
		os.Unsetenv("MARATHON_APP_LABEL_DCOS_PACKAGE_VERSION")
		os.Unsetenv(testCase.envName)
	}
}

                                groups = new ArrayList<>();
                                map.put(mems[ mi ], groups);
                            }
                            if ( !groups.contains(groupSid) )
                                groups.add(groupSid);
                        }
                    }

                    return map;
                }
            }

    return initialPart + penultimate + ":" + ultimate;
  }

  private static byte parseOctet(String ipString, int start, int end) {
    // Note: we already verified that this string contains only hex digits, but the string may still
    // contain non-decimal characters.
    int length = end - start;
    if (length <= 0 || length > 3) {
      throw new NumberFormatException();
    }

                }
                if ( tok.getMechanisms() != null ) {
                    Set<ASN1ObjectIdentifier> mechs = new HashSet<>(Arrays.asList(tok.getMechanisms()));
                    if ( !mechs.contains(NtlmContext.NTLMSSP_OID) ) {
                        throw new SmbUnsupportedOperationException("Server does not support NTLM authentication");
                    }
                }
            }
        }