abstract class CacheBase() {
        def apply(key: Int): Float
    }


   case class CacheLeaf(key: Int, f: Int => Float) extends CacheBase {
        lazy val value = f(key)
        def apply(key: Int) = value
    }

    object CacheNode {
        def apply(size: Int, f: Int => Float): CacheNode = {

            def level(size: Int, mask: Int = 1): Int = size match {
                case 1 | 0 => mask
                case _     => level(size >> 1, mask << 1)
            }

            CacheNode(level(size), 0, f)
        }
    }

    case class CacheNode(level: Int, key: Int, f: Int => Float) extends CacheBase {
        lazy val left = if (level == 0) {
            CacheLeaf(key, f)
        } else {
            CacheNode(level >> 1, key | level, f)
        }

        lazy val right = if (level == 0) {
            CacheLeaf(key, f)
        } else {
            CacheNode(level >> 1, key, f)
        }

        def apply(key: Int) = if ((key & level) > 0) {
            left(key)
        } else {
            right(key)
        }
    }