*/
        public void setEee(final String eee) {
        }

        /**
         * @return int
         */
        public int getFff() {
            return fff_;
        }

        /**
         * @param fff
         */
        public void setFff(final int fff) {
            fff_ = fff;
        }

        /**
         * @return String
         */
        public String getJjj() {

pkg debug/elf, const R_PPC64_REL24_NOTOC = 116
pkg debug/elf, const R_PPC64_REL24_NOTOC R_PPC64
pkg debug/elf, const R_PPC64_SECTOFF_DS = 61
pkg debug/elf, const R_PPC64_SECTOFF_DS R_PPC64
pkg debug/elf, const R_PPC64_SECTOFF_LO_DS = 61
pkg debug/elf, const R_PPC64_SECTOFF_LO_DS R_PPC64
pkg debug/elf, const R_PPC64_TOCSAVE = 109
pkg debug/elf, const R_PPC64_TOCSAVE R_PPC64
pkg debug/elf, const R_PPC64_TPREL16_HIGH = 112

                }
            } while (state != 0);
        } catch (SmbException se) {
            logoff(true);
            connectionState = 0;
            throw se;
        } finally {
            transport.notifyAll();
        }
}
    }
    void logoff( boolean inError ) {
synchronized (transport()) {

        if (connectionState != 2) // not-connected
            return;

        System.arraycopy(NTLMSSP_SIGNATURE, 0, type3, 0, 8);
        pos += 8;

        writeULong(type3, pos, NTLMSSP_TYPE3);
        pos += 4;

        int lmOff = writeSecurityBuffer(type3, 12, lmResponseBytes);
        pos += 8;
        int ntOff = writeSecurityBuffer(type3, 20, ntResponseBytes);
        pos += 8;
        int domOff = writeSecurityBuffer(type3, 28, domainBytes);
        pos += 8;

                                         int outOff, int intLen ) {

        for ( int i = 0; i < intLen; ++i ) {

            outBytes[outOff + i * 4    ] = (byte) ( inInts[inOff + i] >>> 24 );
            outBytes[outOff + i * 4 + 1] = (byte) ( inInts[inOff + i] >>> 16 );
            outBytes[outOff + i * 4 + 2] = (byte) ( inInts[inOff + i] >>>  8 );
            outBytes[outOff + i * 4 + 3] = (byte)   inInts[inOff + i];
        }

			off, decOff, firstPart, decryptSkip, seqNum = getCompressedOffsets(oi, off, decrypt)
			decLength = length
			length = oi.Size - off
			// For negative length we read everything.
			if decLength < 0 {
				decLength = actualSize - decOff
			}

			// Reply back invalid range if the input offset and length fall out of range.
			if decOff > actualSize || decOff+decLength > actualSize {

        private val operatorWithAssignmentVariant = setOf(
            OperatorNameConventions.PLUS,
            OperatorNameConventions.MINUS,
            OperatorNameConventions.TIMES,
            OperatorNameConventions.DIV,
            OperatorNameConventions.REM,
            OperatorNameConventions.MOD,
        )

        private val callArgErrors = setOf(
            Errors.ARGUMENT_PASSED_TWICE,

        @Suppress("UNCHECKED_CAST") val teamcity = project.property("teamcity") as MutableMap<String, Any>
        teamcity["teamcity.build.tempDir"] = ""
    }
}

fun Project.isPerformanceProject() = setOf("build-scan-performance", "performance").contains(name)

/**
 * Whether the project supports running with predictive test selection.
 *
 * Our performance tests don't work with PTS, yet.

        case SMB2_NEGOTIATE:
            c = "SMB2_NEGOTIATE";
            break;
        case SMB2_SESSION_SETUP:
            c = "SMB2_SESSION_SETUP";
            break;
        case SMB2_LOGOFF:
            c = "SMB2_LOGOFF";
            break;
        case SMB2_TREE_CONNECT:
            c = "SMB2_TREE_CONNECT";
            break;
        case SMB2_TREE_DISCONNECT:
            c = "SMB2_TREE_DISCONNECT";

                break;
            case SMB_COM_TREE_DISCONNECT:
                c = "SMB_COM_TREE_DISCONNECT";
                break;
            case SMB_COM_LOGOFF_ANDX:
                c = "SMB_COM_LOGOFF_ANDX";
                break;
            case SMB_COM_ECHO:
                c = "SMB_COM_ECHO";
                break;
            case SMB_COM_MOVE:
                c = "SMB_COM_MOVE";