case s2Type:
		r = s2.NewReader(scannedReader)
	case snappyType:
		r = s2.NewReader(scannedReader, s2.ReaderMaxBlockSize(64<<10))
	default:
		return nil, errInvalidCompressionFormat(fmt.Errorf("unknown compression type '%v'", compType))
	}
	pr.processedReader = newCountUpReader(r)

	return &pr, nil
}

type nopReadCloser struct {
	fn func()
}

  fun request(): Request

  /**
   * Returns the size in bytes of all messages enqueued to be transmitted to the server. This
   * doesn't include framing overhead. If compression is enabled, uncompressed messages size
   * is used to calculate this value. It also doesn't include any bytes buffered by the operating
   * system or network intermediaries. This method returns 0 if no messages are waiting in the

		config.HelpKV{
			Key:         config.BatchSubSys,
			Description: "manage batch job workers and wait times",
		},
		config.HelpKV{
			Key:         config.CompressionSubSys,
			Description: "enable server side compression of objects",
		},
		config.HelpKV{
			Key:             config.IdentityOpenIDSubSys,
			Description:     "enable OpenID SSO support",
			MultipleTargets: true,
		},
		config.HelpKV{

		},
		config.HelpKV{
			Key:         target.KafkaCompressionCodec,
			Description: "specify compression_codec of the Kafka cluster",
			Optional:    true,
			Type:        "none|snappy|gzip|lz4|zstd",
		},
		config.HelpKV{
			Key:         target.KafkaCompressionLevel,
			Description: "specify compression level of the Kafka cluster",
			Optional:    true,
			Type:        "number",
		},
	}

	Number     int               `json:"number"`
	Size       int64             `json:"size"`       // Size of the part on the disk.
	ActualSize int64             `json:"actualSize"` // Original size of the part without compression or encryption bytes.
	ModTime    time.Time         `json:"modTime"`    // Date and time at which the part was uploaded.
	Index      []byte            `json:"index,omitempty" msg:"index,omitempty"`

	}

	if lc, err := globalLifecycleSys.Get(objInfo.Bucket); err == nil {
		lc.SetPredictionHeaders(w, objInfo.ToLifecycleOpts())
	}

	if v, ok := objInfo.UserDefined[ReservedMetadataPrefix+"compression"]; ok {
		if i := strings.LastIndexByte(v, '/'); i >= 0 {
			v = v[i+1:]
		}
		w.Header()[xhttp.MinIOCompressed] = []string{v}
	}

	return nil

- `gradlePluginTest` - build and run gradle plugin tests
- `compilerTest` - build and run all compiler tests

To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run proguard and have jar compression disabled by default.

**OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.

To build Kotlin/Native, see

		"",
	)

	ErrUnexpectedError = newErrFn(
		"Unexpected error",
		"Please contact MinIO at https://slack.min.io",
		"",
	)

	ErrInvalidCompressionIncludesValue = newErrFn(
		"Invalid compression include value",
		"Please check the passed value",
		"Compress extensions/mime-types are delimited by `,`. For eg, MINIO_COMPRESS_MIME_TYPES=\"A,B,C\"",
	)

	ErrInvalidReplicationWorkersValue = newErrFn(

			Value: cfg.SASL.User,
		},
		config.KV{
			Key:   target.KafkaSASLPassword,
			Value: cfg.SASL.Password,
		},
		config.KV{
			Key:   target.KafkaCompressionCodec,
			Value: cfg.Producer.Compression,
		},
		config.KV{
			Key:   target.KafkaCompressionLevel,
			Value: strconv.Itoa(cfg.Producer.CompressionLevel),
		},
	}
	return nil
}

	PrefixEnabledFn func(prefix string) bool // function which returns true if versioning is enabled on prefix

	// IndexCB will return any index created but the compression.
	// Object must have been read at this point.
	IndexCB func() []byte

	// InclFreeVersions indicates that free versions need to be included
	// when looking up a version by fi.VersionID
	InclFreeVersions bool