// instead of the caller.
	f.mu.Lock()
	defer f.mu.Unlock()
	if f.helperPCs == nil {
		f.helperPCs = make(map[uintptr]struct{})
	}
	// repeating code from callerName here to save walking a stack frame
	var pc [1]uintptr
	n := runtime.Callers(2, pc[:]) // skip runtime.Callers + Helper
	if n == 0 {
		panic("testing: zero callers found")
	}

        this.type = SESSION_REQUEST;
        this.calledName = new Name(config, calledName);
        this.callingName = new Name(config, callingName);
    }


    @Override
    int writeTrailerWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        dstIndex += this.calledName.writeWireFormat(dst, dstIndex);
        dstIndex += this.callingName.writeWireFormat(dst, dstIndex);

  auto callsite_loc = llvm::dyn_cast<CallSiteLoc>(attr);

  if (!mlir::isa<NameLoc>(callsite_loc.getCaller())) return false;
  StringRef caller_name =
      mlir::cast<NameLoc>(callsite_loc.getCaller()).getName().strref();
  return caller_name.starts_with(kQuantizationUnitPrefix) &&
         caller_name.ends_with(kQuantizationUnitSuffix);
}

std::optional<QuantizationUnitLoc::QuantizationUnit>
FindQuantizationUnitFromLoc(Location loc) {

public class SessionRequestPacket extends SessionServicePacket {

    private Name calledName, callingName;

    SessionRequestPacket() {
        calledName = new Name();
        callingName = new Name();
    }
    public SessionRequestPacket( Name calledName, Name callingName ) {
        type = SESSION_REQUEST;
        this.calledName = calledName;
        this.callingName = callingName;
    }

    }
    public NbtSocket( NbtAddress address, String calledName, int port,
                                InetAddress localAddr, int localPort ) throws IOException {
        super( address.getInetAddress(), ( port == 0 ? SSN_SRVC_PORT : port ),
                                localAddr, localPort );
        this.address = address;
        if( calledName == null ) {
            this.calledName = address.hostName;
        } else {

        } else {
            calledName = ((InetAddress)addr).getHostName();
            if( isDotQuadIP( calledName )) {
                calledName = NbtAddress.SMBSERVER_NAME;
            } else {
                int i = calledName.indexOf( '.' );
                if( i > 1 && i < 15 ) {
                    calledName = calledName.substring( 0, i ).toUpperCase();

        }

        this.calledName = ( (InetAddress) this.addr ).getHostName();
        if ( isDotQuadIP(this.calledName) ) {
            this.calledName = NbtAddress.SMBSERVER_NAME;
        }
        else {
            int i = this.calledName.indexOf('.');
            if ( i > 1 && i < 15 ) {
                this.calledName = this.calledName.substring(0, i).toUpperCase();
            }

                case 0x1D:
                    calledName = SMBSERVER_NAME;
            }
        }

        return calledName;
    }
    public String nextCalledName() {

        if( calledName == hostName.name ) {
            calledName = SMBSERVER_NAME;
        } else if( calledName == SMBSERVER_NAME ) {
            NbtAddress[] addrs;

            try {
                addrs = CLIENT.getNodeStatus( this );

        TestResult largerClass = new TestResult('name', 0, class3)
        TestResult smallerName = new TestResult('a', 0, class1)
        TestResult largerName = new TestResult('z', 0, class1)

        expect:
        [result, largerName, smallerClass, largerClass, smallerName].sort() == [smallerClass, smallerName, result, largerName, largerClass]
    }

    def doesNotDiscardDuplicatesWhenSorting() {

    @Override
    public String firstCalledName () {

        this.calledName = this.hostName.name;

        if ( Character.isDigit(this.calledName.charAt(0)) ) {
            int i, len, dots;
            char[] data;

            i = dots = 0; /* quick IP address validation */
            len = this.calledName.length();
            data = this.calledName.toCharArray();