listOf(
          Mapping(0x40000, 0x40180, TYPE_DISALLOWED, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x40000, 0x4007f, TYPE_DISALLOWED, ByteString.EMPTY),
      Mapping(0x40080, 0x400ff, TYPE_DISALLOWED, ByteString.EMPTY),
      Mapping(0x40100, 0x4017f, TYPE_DISALLOWED, ByteString.EMPTY),
      Mapping(0x40180, 0x40180, TYPE_DISALLOWED, ByteString.EMPTY),
    )
  }

    // 1.
    "disallowed ".encodeUtf8(),
    // 2.
    "disallowed_STD3_mapped ".encodeUtf8(),
    // 3.
    "disallowed_STD3_valid ".encodeUtf8(),
    // 4.
    "ignored ".encodeUtf8(),
    // 5.
    "mapped ".encodeUtf8(),
    // 6.
    "valid ".encodeUtf8(),
  )

internal const val TYPE_DEVIATION = 0
internal const val TYPE_DISALLOWED = 1

02D8          ; disallowed_STD3_mapped ; 0020 0306     # 1.1  BREVE
02D9          ; disallowed_STD3_mapped ; 0020 0307     # 1.1  DOT ABOVE
02DA          ; disallowed_STD3_mapped ; 0020 030A     # 1.1  RING ABOVE
02DB          ; disallowed_STD3_mapped ; 0020 0328     # 1.1  OGONEK
02DC          ; disallowed_STD3_mapped ; 0020 0303     # 1.1  SMALL TILDE

  return when (type) {
    TYPE_IGNORED -> TYPE_IGNORED

    TYPE_MAPPED,
    TYPE_DISALLOWED_STD3_MAPPED,
    -> TYPE_MAPPED

    TYPE_DEVIATION,
    TYPE_DISALLOWED_STD3_VALID,
    TYPE_VALID,
    -> TYPE_VALID

    TYPE_DISALLOWED -> TYPE_DISALLOWED

    else -> error("unexpected type: $type")
  }
}

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

		{ObjectOpts{Name: "c2test", VersionID: "vid", DeleteMarker: true, OpType: DeleteReplicationType}, cfgs[1], false},             // 13. permanent delete of DeleteMarker version, disallowed by DeleteReplication status

 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].

    override val rangeStart: Int,
    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(
    override val rangeStart: Int,
    private val mappedTo: ByteString,
  ) : MappedRange {
    val b1: Int

	sseS3 := crypto.S3.IsEncrypted(objInfo.UserDefined)
	if !sseKMS && !sseS3 { // neither sse-s3 nor sse-kms disallowed
		return errInvalidEncryptionParameters
	}
	if sseKMS && r.Encryption.Type == sses3 { // previously encrypted with sse-kms, now sse-s3 disallowed
		return errInvalidEncryptionParameters
	}
	versioned := globalBucketVersioningSys.PrefixEnabled(srcBucket, srcObject)

  max-file-length: 0
  mixins-before-declarations: 2
  no-attribute-selectors: 0
  no-color-hex: 0
  no-color-keywords: 0
  no-color-literals: 0
  no-combinators: 0
  no-css-comments: 2
  no-debug: 2
  no-disallowed-properties: 2
  no-duplicate-properties: 2
  no-empty-rulesets: 2
  no-extends: 2
  no-ids: 0
  no-invalid-hex: 2
  no-important: 0
  no-mergeable-selectors: 2
  no-misspelled-properties: 2

        new SecurityManager() {
          @Override
          public void checkPermission(Permission p) {
            if (readSystemProperty.equals(p)) {
              throw new SecurityException("Disallowed: " + p);
            }
          }
        };
    System.setSecurityManager(disallowPropertySecurityManager);

    settableFutureClass = classReloader.loadClass(SettableFuture.class.getName());

    /*