crc0 = computeForWord(crc0);
        crc1 = computeForWord(crc1);
        crc2 = computeForWord(crc2);
        crc3 = computeForWord(crc3);
        crc0 ^= bb.getInt();
        crc1 ^= bb.getInt();
        crc2 ^= bb.getInt();
        crc3 ^= bb.getInt();
      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }

	r.mu.Lock()
	defer r.mu.Unlock()
	getDst := func(n int) []byte {
		if cap(dst) < n {
			return make([]byte, n)
		}
		return dst[:n]
	}

	if r.w == r.r {
		if r.isFull {
			buf := getDst(r.size)
			copy(buf, r.buf[r.r:])
			copy(buf[r.size-r.r:], r.buf[:r.w])
			return buf
		}
		return nil
	}

	if r.w > r.r {
		buf := getDst(r.w - r.r)
		copy(buf, r.buf[r.r:r.w])

	}
	_ = matcher.HostMatcher(k, v)
	return 1
}

func FuzzMetadataListMatcher(data []byte) int {
	f := fuzz.NewConsumer(data)
	filter, err := f.GetString()
	if err != nil {
		return 0
	}
	number, err := f.GetInt()
	if err != nil {
		return 0
	}
	maxKeys := number % 100
	keys := make([]string, 0, maxKeys)
	for i := 0; i < maxKeys; i++ {
		key, err := f.GetString()
		if err != nil {
			return 0
		}

            hasPackageStatement = source.getAST().getPackageName() != null;
        }
    }

    private static class EmptyScriptDetector extends CompilationUnit.SourceUnitOperation {
        private boolean emptyScript;
        private boolean hasMethods;

        @Override
        public void call(SourceUnit source) {
            if (!source.getAST().getMethods().isEmpty()) {
                hasMethods = true;

 */

package jcifs.smb1.smb1;

import jcifs.smb1.Config;

class SmbComReadAndX extends AndXServerMessageBlock {

    private static final int BATCH_LIMIT = Config.getInt( "jcifs.smb1.smb.client.ReadAndX.Close", 1 );

    private long offset;
    private int fid,
        openTimeout;
int maxCount, minCount, remaining;

    SmbComReadAndX() {
        super( null );

        this.originalBuilder = builder;
        this.builder = DynamicObjectUtil.asDynamicObject(builder);
        this.antlibClassLoader = antlibClassLoader;
    }

    public AntBuilderDelegate getAnt() {
        return this;
    }

    public void taskdef(Map<String, String> args) {
        Set<String> argNames = args.keySet();
        if (argNames.equals(ImmutableSet.of("name", "classname"))) {
            try {

        if (CompactHashing.getHashPrefix(entry, mask) == hashPrefix
            && Objects.equal(object, elements[entryIndex])) {
          return false;
        }
        next = CompactHashing.getNext(entry, mask);
        bucketLength++;
      } while (next != UNSET);

      if (bucketLength >= MAX_HASH_BUCKET_LENGTH) {
        return convertToHashFloodingResistantImplementation().add(object);
      }

                        Set<String> containers = new LinkedHashSet<>();
                        containers.add("org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/" + model.getJdt().getJavaRuntimeName() + "/");
                        containers.addAll(model.getClasspath().getContainers());
                        model.getClasspath().setContainers(containers);
                    }
                });

  /** Sets the value reference for this entry. */
  void setValueReference(ValueReference<K, V> valueReference);

  /** Returns the next entry in the chain. */
  @CheckForNull
  ReferenceEntry<K, V> getNext();

  /** Returns the entry's hash. */
  int getHash();

  /** Returns the key for this entry. */
  @CheckForNull
  K getKey();

  /*

     */

    @Override
    public void call(SourceUnit source) throws CompilationFailedException {
        List<Statement> statements = source.getAST().getStatementBlock().getStatements();
        for (Statement statement : statements) {
            ScriptBlock scriptBlock = AstUtils.detectScriptBlock(statement, SCRIPT_BLOCK_NAMES);
            if (scriptBlock == null) {