this.init = init;
        this.last = last;
    }

    /**
     * @return The initial steps of this chain, or null if this chain only contains one step.
     */
    @Nullable
    public TransformChain getInit() {
        return init;
    }

    /**
     * @return The last step of this chain.
     */
    public TransformStep getLast() {
        return last;
    }

    public boolean requiresDependencies() {

          generator_op, generator_op.getFinalizeFunc());

  if (!init_function || !next_function || !finalize_function) {
    return failure();
  }

  CreateCall(generator_op, init_function, generator_region.getInit(),
             generator_region.getInitFuncOtherArgs(),
             /*use_region_args=*/true, /*forward_block_args=*/false);
  CreateCall(generator_op, next_function, generator_region.getNext(),

  int n;
  if (point.isParent()) {
    // The op itself branches to `init` first.
    regions.push_back(
        RegionSuccessor(&getInit(), getInit().front().getArguments()));
  } else if (point.getRegionOrNull() == &getInit()) {
    // `init` branches to `next`, passing along the arguments given to `init`'s
    // yield. Said arguments precede the "other args".
    n = getInitFuncOtherArgs().size();

      CollectExternValues(regional.getRegions());

  if (!extern_values.empty()) return failure();

  init_name = GetName(regional, "_init");
  init_name = ExtractSingleBlockRegion(symbol_table, regional.getInit(),
                                       init_name, extern_values, worklist,
                                       /*extern_values_passthrough=*/false,
                                       /*only_one_return_value=*/false,

  ASSERT_EQ(-2147483648, op.getLhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getRhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getRhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getOutputQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getOutputQuantizationMinValAttr().getInt());

  if (mlir::cast<IntegerAttr>(elements.front()).getInt() != 1 ||
      mlir::cast<IntegerAttr>(elements.back()).getInt() != 1)
    return false;

  Builder b(op->getContext());
  *x = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[1]).getInt());
  *y = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[2]).getInt());
  *z = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[3]).getInt());

  return true;
}

        this.flags2 = Config.getInt(p, "jcifs.smb.client.flags2", 0);

        this.capabilities = Config.getInt(p, "jcifs.smb.client.capabilities", 0);

        this.sessionLimit = Config.getInt(p, "jcifs.smb.client.ssnLimit", SmbConstants.DEFAULT_SSN_LIMIT);

        this.maxRequestRetries = Config.getInt(p, "jcifs.smb.client.maxRequestRetries", 2);

    static final int LPORT = Config.getInt( "jcifs.smb1.smb.client.lport", 0 );
    static final int MAX_MPX_COUNT = Config.getInt( "jcifs.smb1.smb.client.maxMpxCount", DEFAULT_MAX_MPX_COUNT );
    static final int SND_BUF_SIZE = Config.getInt( "jcifs.smb1.smb.client.snd_buf_size", DEFAULT_SND_BUF_SIZE );
    static final int RCV_BUF_SIZE = Config.getInt( "jcifs.smb1.smb.client.rcv_buf_size", DEFAULT_RCV_BUF_SIZE );

        int andRecordCount = JsonPath.from(andResponse).getInt("record_count");

        Map<String, String> params = new HashMap<>();
        params.put("q", query);
        params.put("num", "100");
        String response = checkMethodBase(new HashMap<>()).params(params).get("/api/v1/documents").asString();
        assertTrue(JsonPath.from(response).getInt("record_count") > andRecordCount);

	if err != nil {
		return si, err
	}
	return si, nil
}

// Gets a protocol from global var protocols
func getProtocolInstance(f *fuzz.ConsumeFuzzer) (protocol.Instance, error) {
	pIndex, err := f.GetInt()
	if err != nil {
		return protocol.Unsupported, errors.New("could not create protocolInstance")
	}
	i := protocols[pIndex%len(protocols)]
	return i, nil
}

// Creates a new fuzzed Port