// The next four bits is the CM (compression method), which is 8 for deflate.
	z.scratch[0] = 0x78
	// The next two bits is the FLEVEL (compression level). The four values are:
	// 0=fastest, 1=fast, 2=default, 3=best.
	// The next bit, FDICT, is set if a dictionary is given.
	// The final five FCHECK bits form a mod-31 checksum.
	switch z.level {
	case -2, 0, 1:
		z.scratch[1] = 0 << 6

			if err = lookupDeprecatedScannerConfig(kvs, &cfg); err != nil {
				return cfg, err
			}
		}
	}

	switch speed := env.Get(EnvSpeed, kvs.GetWithDefault(Speed, DefaultKVS)); speed {
	case "fastest":
		cfg.Delay, cfg.MaxWait, cfg.Cycle = 0, 0, time.Second
	case "fast":
		cfg.Delay, cfg.MaxWait, cfg.Cycle = 1, 100*time.Millisecond, time.Minute
	case "default":

    List<Class<?>> result = Lists.newArrayList();
    NEXT_CANDIDATE:
    for (Class<?> candidate : Iterables.filter(candidateClasses, classFilter)) {
      for (Class<?> testClass : testClasses.get(candidate)) {
        if (hasTest(testClass, explicitTestNames)) {
          // covered by explicit test
          continue NEXT_CANDIDATE;
        }
      }
      result.add(candidate);
    }
    return result;
  }

pkill minio
rm -rf /tmp/xl
rm -rf /tmp/xltier

if [ ! -f ./mc ]; then
	wget --quiet -O mc https://dl.minio.io/client/mc/release/linux-amd64/mc &&
		chmod +x mc
fi

export CI=true
export MINIO_SCANNER_SPEED=fastest

(minio server http://localhost:9000/tmp/xl/{1...10}/disk{0...1} 2>&1 >/tmp/decom.log) &
pid=$!

export MC_HOST_myminio="http://minioadmin:minioadmin@localhost:9000/"

./mc ready myminio

    List<Class<?>> result = Lists.newArrayList();
    NEXT_CANDIDATE:
    for (Class<?> candidate : Iterables.filter(candidateClasses, classFilter)) {
      for (Class<?> testClass : testClasses.get(candidate)) {
        if (hasTest(testClass, explicitTestNames)) {
          // covered by explicit test
          continue NEXT_CANDIDATE;
        }
      }
      result.add(candidate);
    }
    return result;
  }

//  1 type filtering
//  2 pruning
//  3 postorder calls to f
//  4 stack
// Rather than offer all of them in the API,
// only a few combinations are exposed:
// - Preorder is the fastest and has fewest features,
//   but is the most commonly needed traversal.
// - Nodes and WithStack both provide pruning and postorder calls,
//   even though few clients need it, because supporting two versions

  // If true, the model input doesn't require user specified input ranges.
  bool post_training_quantization = false;

  // Whether to allow dynamic range quantization. This is the easiest
  // quantization mode which doesn't require QAT or sample inputs.
  // This option only targets `DT_HALF` and `DT_QINT8` inference type.
  bool weight_quantization = false;

import (
	"image"
	"image/color"
	"image/png"
	"os"
	"testing"
	"testing/quick"
)

// slowestRGBA is a draw.Image like image.RGBA, but it is a different type and
// therefore does not trigger the draw.go fastest code paths.
//
// Unlike slowerRGBA, it does not implement the draw.RGBA64Image interface.
type slowestRGBA struct {
	Pix    []uint8
	Stride int
	Rect   image.Rectangle
}

//         greaterThan: 1MiB # match objects with size greater than this value (e.g. 1MiB)
//       purge:
//           # retainVersions: 0 # (default) delete all versions of the object. This option is the fastest.
//           # retainVersions: 5 # keep the latest 5 versions of the object.
//
//     - type: deleted # objects with delete marker as their latest version

The easiest way to avoid this performance penalty is to not use annotation processors.
However, if you need to use them, make sure you set the annotation processor classpath explicitly to include only the libraries needed for annotation processing.