Kotlin extensions for java BitSet, with shift left, shit right and shift intersect

BitSet.kt

infix fun shr(n: Int) {
    require(n >= 0) { "'n' must be >= 0" }
    if (n == 0 || words.isEmpty()) { return }
    val step = n / 64
    val shift = n % 64
    if (shift == 0 && step == 0) { return }
    for (i in words.indices) {
        words[i] = when {
            i < words.size - 1 - step -> {
                if (shift == 0) { words[i + step] }
                else { (words[i + step] ushr shift) or (words[i + step + 1] shl (64 - shift)) }
            }
            i == words.size - 1 - step -> {
                words[i + step] ushr shift
            }
            else /* i > word.size - 1 - step */ -> {
                0
            }
        }
    }
}

fun shrIntersect(n: Int, other: BitSet): Boolean {
    require(n >= 0) { "'n' must be >= 0" }
    if (n == 0 || words.isEmpty()) { return intersects(other) }
    val step = n / 64
    val shift = n % 64
    if (shift == 0 && step == 0) { return intersects(other) }
    for (i in words.indices) {
        val word = when {
            i < words.size - 1 - step -> {
                if (shift == 0) { words[i + step] }
                else { (words[i + step] ushr shift) or (words[i + step + 1] shl (64 - shift)) }
            }
            i == words.size - 1 - step -> {
                words[i + step] ushr shift
            }
            else /* i > word.size - 1 - step */ -> {
                0
            }
        }
        if (other.words[i] and word != 0L) {
            return true
        }
    }
    return false
}

infix fun shl(n: Int) {
    require(n >= 0) { "'n' must be >= 0" }
    if (n == 0 || words.isEmpty()) { return }
    val step = n / 64
    val shift = n % 64
    if (shift == 0 && step == 0) { return }
    for (i in words.size - 1 downTo 0) {
        words[i] = when {
            i > step -> {
                if (shift == 0) { words[i - step] }
                else { (words[i - step] shl shift) or (words[i - step - 1] ushr (64 - shift)) }
            }
            i == step -> {
                words[i - step] shl shift
            }
            else /* i < step */ -> {
                0
            }
        }
    }
}

fun shlIntersect(n: Int, other: BitSet): Boolean {
    require(n >= 0) { "'n' must be >= 0" }
    if (n == 0 || words.isEmpty()) { return intersects(other) }
    val step = n / 64
    val shift = n % 64
    if (shift == 0 && step == 0) { return intersects(other) }
    for (i in 0 until min(words.size, other.words.size)) {
        val word = when {
            i > step -> {
                if (shift == 0) { words[i - step] }
                else { (words[i - step] shl shift) or (words[i - step - 1] ushr (64 - shift)) }
            }
            i == step -> {
                words[i - step] shl shift
            }
            else /* i < step */ -> {
                0
            }
        }
        if (other.words[i] and word != 0L) {
            return true
        }
    }
    return false
}