dstIndex += 2;
        writeInt4( resumeKey, dst, dstIndex );
        dstIndex += 4;
        writeInt2( flags, dst, dstIndex );
        dstIndex += 2;
        dstIndex += writeString( filename, dst, dstIndex );

        return dstIndex - start;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }

			err = msgp.WrapError(err)
			return
		}
		(*z) = StatusType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z StatusType) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteString(string(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z StatusType) MarshalMsg(b []byte) (o []byte, err error) {

        dstIndex += 2;
        dst[ dstIndex++ ] = (byte) 0x00;
        dst[ dstIndex++ ] = (byte) 0x00;
        dst[ dstIndex++ ] = (byte) 0x00;
        dst[ dstIndex++ ] = (byte) 0x00;
        dstIndex += writeString(this.path, dst, dstIndex);

        return dstIndex - start;
    }


    /**
     * @param informationLevel2
     * @return
     */
    static long mapInformationLevel ( int il ) {

		return r.Filter.Tag.String()
	}
	if len(r.Filter.And.Tags) != 0 {
		var buf bytes.Buffer
		for _, t := range r.Filter.And.Tags {
			if buf.Len() > 0 {
				buf.WriteString("&")
			}
			buf.WriteString(t.String())
		}
		return buf.String()
	}
	return ""
}

// Validate - validates the rule element
func (r Rule) Validate() error {
	if err := r.validateID(); err != nil {

		return
	}
	for za0002 := range z.RebalancedBuckets {
		err = en.WriteString(z.RebalancedBuckets[za0002])
		if err != nil {
			err = msgp.WrapError(err, "RebalancedBuckets", za0002)
			return
		}
	}
	// write "bu"
	err = en.Append(0xa2, 0x62, 0x75)
	if err != nil {
		return
	}
	err = en.WriteString(z.Bucket)
	if err != nil {
		err = msgp.WrapError(err, "Bucket")
		return
	}

        return sb.toString();
    }

    @Test
    void testOptionsAsHtml() throws IOException {
        Path options = Paths.get("target/test-classes/options.html");
        Files.writeString(options, getOptionsAsHtml(), StandardCharsets.UTF_8);
    }

}

func parseGoroutineType2(path string) (map[time.Duration][]string, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	bf := bytes.Buffer{}

	save := func(s string) {
		bf.WriteString(s + "\n")
	}
	reset := func() {
		bf.Reset()
	}

	ret := make(map[time.Duration][]string)

	s := bufio.NewScanner(f)
	s.Split(bufio.ScanLines)

	var (
		t            time.Duration

        flags2 = 0;
        errorCode = 0;
        received = false;
        digest = null;
    }
    int writeString( String str, byte[] dst, int dstIndex ) {
        return writeString( str, dst, dstIndex, useUnicode );
    }
    int writeString( String str, byte[] dst, int dstIndex, boolean useUnicode ) {
        int start = dstIndex;

        try {
            if( useUnicode ) {

        SMBUtil.writeInt2(this.informationLevel, dst, dstIndex);
        dstIndex += 2;
        SMBUtil.writeInt4(this.searchStorageType, dst, dstIndex);
        dstIndex += 4;
        dstIndex += writeString(this.path + this.wildcard, dst, dstIndex);

        return dstIndex - start;
    }


    @Override
    protected int writeDataWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }

        return 0;
    }
    int writeBytesWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        dst[dstIndex++] = (byte)0x04;
        dstIndex += writeString( path, dst, dstIndex );

        return dstIndex - start;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }