type FileHeader32 struct {
	Fmagic   uint16 // Target machine
	Fnscns   uint16 // Number of sections
	Ftimedat uint32 // Time and date of file creation
	Fsymptr  uint32 // Byte offset to symbol table start
	Fnsyms   uint32 // Number of entries in symbol table
	Fopthdr  uint16 // Number of bytes in optional header
	Fflags   uint16 // Flags
}

type FileHeader64 struct {
	Fmagic   uint16 // Target machine
	Fnscns   uint16 // Number of sections

  /dev/loopX ... Descriptor lock(Loopback device to mapFile under global map path)
  /var/lib/kubelet/plugins/kubernetes.io/csi/volumeDevices/{specName}/dev/ ... Global map path
  /var/lib/kubelet/plugins/kubernetes.io/csi/volumeDevices/{specName}/dev/{podUID} ... MapFile(Bind mount to publish Path)
  /var/lib/kubelet/plugins/kubernetes.io/csi/volumeDevices/staging/{specName} ... Staging path

//            }
        }
        baselineVersions
    }
...
```

## Perform the search

While doing the search no other activity should be done on the machine. Therefore, it
is best to have a dedicated machine running the search, e.g., using the CI infrastructure.

In order to check if the test passes for the current revision you can use [check-rev.sh](check-rev.sh).

        mapping.getVersionUsedBy(version("1.0-rc-3")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.0")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.1-milestone-1")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.1-rc-1")).get() == CacheVersion.of(2)
        mapping.getVersionUsedBy(version("2.0")).get() == CacheVersion.of(2)

          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

        ConstantToDependentsMapping mapping = merger.merge(newMapping, null, [] as Set)

        then:
        mapping.getConstantDependentsForClass("a").accessibleDependentClasses == ["1", "2"] as Set
        mapping.getConstantDependentsForClass("b").accessibleDependentClasses == ["3"] as Set
        mapping.getConstantDependentsForClass("c").accessibleDependentClasses == [] as Set

          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

internal fun mergeAdjacentRanges(mappings: List<Mapping>): List<Mapping> {
  var index = 0
  val result = mutableListOf<Mapping>()

  while (index < mappings.size) {
    val mapping = mappings[index]
    val type = canonicalizeType(mapping.type)
    val mappedTo = mapping.mappedTo

    var unionWith: Mapping = mapping
    index++

    while (index < mappings.size) {

    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0232, 0x0232, TYPE_MAPPED, "a".encodeUtf8()),
          Mapping(0x0233, 0x0233, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0234, 0x0236, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0237, 0x0239, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x023a, 0x023a, TYPE_MAPPED, "b".encodeUtf8()),
        ),
      ),
    ).containsExactly(