var inconsistent int
	for i, meta := range metaArr {
		if disks[i] == nil {
			// Assuming offline drives as inconsistent,
			// to be safe and fallback to original
			// distribution order.
			inconsistent++
			continue
		}
		if !meta.IsValid() {
			inconsistent++
			continue
		}
		if meta.XLV1 != fi.XLV1 {
			inconsistent++
			continue
		}

            }
        } else if (since instanceof SinceTagStatus.Inconsistent inconsistent) {
            return acceptOrReject(member, Violation.error(member, String.format(SINCE_INCONSISTENT_ERROR_MESSAGE, inconsistent.getVersions())));
        } else if (since instanceof SinceTagStatus.NotNeeded) {
            return null;

				// number of items than number of online disks.
				inconsistent++
				continue
			}
			if meta.Erasure.Distribution[i] != meta.Erasure.Index {
				// Mismatch indexes with distribution order
				inconsistent++
			}
		}
	}

	erasureDistributionReliable := inconsistent <= len(partsMetadata)/2

	metaErrs := make([]error, len(errs))

	for i := range onlineDisks {

 */

package gradlebuild.binarycompatibility.sources

sealed interface SinceTagStatus {
    data class Present(val version: String): SinceTagStatus
    data object NotNeeded: SinceTagStatus
    data class Inconsistent(val versions: List<String?>): SinceTagStatus
    data object Missing: SinceTagStatus

        run: |
          sudo sysctl net.ipv6.conf.all.disable_ipv6=0
          sudo sysctl net.ipv6.conf.default.disable_ipv6=0
          make verify-healing
          make verify-healing-inconsistent-versions
          make verify-healing-with-root-disks

    assertEquals(Country.class, bimap.valueType());
  }

  public void testIterationOrder() {
    // The enum orderings are alphabetical, leading to the bimap and its inverse
    // having inconsistent iteration orderings.
    Map<Currency, Country> map =
        ImmutableMap.of(
            Currency.DOLLAR, Country.CANADA,
            Currency.PESO, Country.CHILE,
            Currency.FRANC, Country.SWITZERLAND);

	@echo "Verify healing with rewrite"
	@(env bash $(PWD)/buildscripts/rewrite-old-new.sh)

verify-healing-inconsistent-versions: install-race ## verify resolving inconsistent versions
	@echo "Verify resolving inconsistent versions build with race"
	@(env bash $(PWD)/buildscripts/resolve-right-versions.sh)

build-debugging:
	@(env bash $(PWD)/docs/debugging/build.sh)

* **Inconsistent API surface**: Public APIs with mixed spelling conventions appear less professional and polished
* **Harder for non-native speakers**: Contributors and users for whom English is a second language benefit from a single, consistent convention

- Some Unformatted - format all and return success.
- Any JBOD inconsistent - return failure
- Some are corrupt (missing format.json) - return failure
- Any unrecognized disks - return failure

Some disks are offline and we have quorum.
-----------------
- Some unformatted - format all and return success,
  treat disks offline as corrupted.
- Any JBOD inconsistent - return failure
- Some are corrupt (missing format.json)

                (sinceTags.first() ?: fallback)?.let { SinceTagStatus.Present(it) } ?: SinceTagStatus.Missing
            }

            else -> {
                SinceTagStatus.Inconsistent(sinceTags)
            }
        }
    }

    private
    fun KtDeclaration?.getSinceStatus(fallback: String? = null): SinceTagStatus =