if ( this.queryAddress.hostName.isUnknown() ) {
                    this.queryAddress.hostName = new Name(this.config, n, hexCode, scope);
                }
                this.queryAddress.groupName = groupName;
                this.queryAddress.nodeType = ownerNodeType;
                this.queryAddress.isBeingDeleted = isBeingDeleted;
                this.queryAddress.isInConflict = isInConflict;

    Name hostName;
    int address, nodeType;
    boolean groupName, isBeingDeleted, isInConflict, isActive, isPermanent, isDataFromNodeStatus;
    byte[] macAddress;
    String calledName;


    NbtAddress ( Name hostName, int address, boolean groupName, int nodeType ) {
        this.hostName = hostName;
        this.address = address;
        this.groupName = groupName;
        this.nodeType = nodeType;
    }

docker_switch_user() {
	if [ -n "${MINIO_USERNAME}" ] && [ -n "${MINIO_GROUPNAME}" ]; then
		if [ -n "${MINIO_UID}" ] && [ -n "${MINIO_GID}" ]; then
			chroot --userspec=${MINIO_UID}:${MINIO_GID} / "$@"
		else
			echo "${MINIO_USERNAME}:x:1000:1000:${MINIO_USERNAME}:/:/sbin/nologin" >>/etc/passwd
			echo "${MINIO_GROUPNAME}:x:1000" >>/etc/group
			chroot --userspec=${MINIO_USERNAME}:${MINIO_GROUPNAME} / "$@"
		fi
	else
		exec "$@"
	fi
}

    
                    if( queryAddress.hostName == NbtAddress.UNKNOWN_NAME ) {
                        queryAddress.hostName = new Name( n, hexCode, scope );
                    }
                    queryAddress.groupName = groupName;
                    queryAddress.nodeType = ownerNodeType;
                    queryAddress.isBeingDeleted = isBeingDeleted;
                    queryAddress.isInConflict = isInConflict;

            return 0;
        }
        boolean groupName = (( src[srcIndex] & 0x80 ) == 0x80 ) ? true : false;
        int nodeType = ( src[srcIndex] & 0x60 ) >> 5;
        srcIndex += 2;
        int address = readInt4( src, srcIndex );
        if( address != 0 ) {
            addrEntry[addrIndex] = new NbtAddress( recordName, address, groupName, nodeType );
        } else {
            addrEntry[addrIndex] = null;

            return 0;
        }
        boolean groupName = ( ( src[ srcIndex ] & 0x80 ) == 0x80 ) ? true : false;
        int nodeType = ( src[ srcIndex ] & 0x60 ) >> 5;
        srcIndex += 2;
        int address = readInt4(src, srcIndex);
        if ( address != 0 ) {
            this.addrEntry[ this.addrIndex ] = new NbtAddress(this.recordName, address, groupName, nodeType);
        }
        else {

        this.nodeType = nodeType;
    }

    NbtAddress( Name hostName,
                int address,
                boolean groupName,
                int nodeType,
                boolean isBeingDeleted,
                boolean isInConflict,
                boolean isActive,
                boolean isPermanent,
                byte[] macAddress ) {

	for _, item := range groupPolicyMappingsList {
		groupName := strings.TrimSuffix(item, ".json")
		if err := iamOS.loadMappedPolicy(ctx, groupName, regUser, true, cache.iamGroupPolicyMap); err != nil && !errors.Is(err, errNoSuchPolicy) {
			return fmt.Errorf("unable to load the policy mapping for the group `%s`: %w", groupName, err)
		}
	}

	bootstrapTraceMsg("loading service accounts")

							</sources>
						</mapping>
						<mapping>
							<directory>${packaging.fess.var.dir}</directory>
							<filemode>755</filemode>
							<username>${packaging.fess.user}</username>
							<groupname>${packaging.fess.group}</groupname>
						</mapping>
						<!-- bin -->
						<mapping>
							<directory>${packaging.fess.bin.dir}</directory>
							<filemode>755</filemode>
							<sources>
								<source>

func (h *headerGNU) magic() []byte       { return h[257:][:6] }
func (h *headerGNU) version() []byte     { return h[263:][:2] }
func (h *headerGNU) userName() []byte    { return h[265:][:32] }
func (h *headerGNU) groupName() []byte   { return h[297:][:32] }
func (h *headerGNU) devMajor() []byte    { return h[329:][:8] }
func (h *headerGNU) devMinor() []byte    { return h[337:][:8] }
func (h *headerGNU) accessTime() []byte  { return h[345:][:12] }