Solution #bb8caee8-ea25-41b3-acd9-0e7fe23b6f87

def solve(input):
    try:
        data = input.get("data", "")
        if not isinstance(data, str):
            data = str(data)

        n = len(data)
        if n == 0:
            return 0.0

        def vlen(x):
            c = 1
            while x >= 128:
                x >>= 7
                c += 1
            return c

        def z_algorithm(s):
            m = len(s)
            z = [0] * m
            l = 0
            r = 0
            for i in range(1, m):
                if i <= r:
                    k = i - l
                    zi = z[k]
                    if zi > r - i + 1:
                        zi = r - i + 1
                    z[i] = zi
                while i + z[i] < m and s[z[i]] == s[i + z[i]]:
                    z[i] += 1
                if i + z[i] - 1 > r:
                    l = i
                    r = i + z[i] - 1
            return z

        def period_cost(s):
            m = len(s)
            if m <= 1:
                return m
            z = z_algorithm(s)
            best = m
            for p in range(1, m):
                if m % p == 0 and z[p] >= m - p:
                    cost = 1 + vlen(p) + p + vlen(m // p)
                    if cost < best:
                        best = cost
            return best

        def lz_cost_and_verify(s):
            m = len(s)
            if m == 0:
                return 0

            max_len = 255
            min_match = 4
            max_candidates = 24

            last = {}
            prev = [-1] * m

            dp = [0] * (m + 1)
            choice = [None] * m
            dp[m] = 0

            for i in range(m - 1, -1, -1):
                lit_best = 1 + dp[i + 1]
                best_cost = lit_best
                best = ("L", 1)

                p = last.get(s[i], -1)
                cnt = 0
                while p != -1 and cnt < max_candidates:
                    cnt += 1
                    l = 0
                    lim = m - i
                    if lim > max_len:
                        lim = max_len
                    while l < lim and s[p + l] == s[i + l]:
                        l += 1
                    if l >= min_match:
                        c = 1 + vlen(i - p) + vlen(l) + dp[i + l]
                        if c < best_cost:
                            best_cost = c
                            best = ("M", i - p, l)
                    p = prev[p]

                choice[i] = best
                dp[i] = best_cost

                prev[i] = last.get(s[i], -1)
                last[s[i]] = i

            out = []
            i = 0
            comp_cost = 0
            while i < m:
                ch = choice[i]
                if ch[0] == "L":
                    out.append(s[i])
                    comp_cost += 1
                    i += 1
                else:
                    off, ln = ch[1], ch[2]
                    if off <= 0 or off > len(out):
                        return None
                    start = len(out) - off
                    for k in range(ln):
                        out.append(out[start + k])
                    comp_cost += 1 + vlen(off) + vlen(ln)
                    i += ln

            if "".join(out) != s:
                return None
            return comp_cost

        def hybrid_block_cost(s):
            m = len(s)
            if m == 0:
                return 0

            dp = [0] * (m + 1)
            dp[m] = 0

            max_raw = 64
            max_pat = 64

            for i in range(m - 1, -1, -1):
                best = 1 + dp[i + 1]

                lim = m - i
                if lim > max_raw:
                    lim = max_raw
                for ln in range(2, lim + 1):
                    cost = 1 + vlen(ln) + ln + dp[i + ln]
                    if cost < best:
                        best = cost

                run_ch = s[i]
                j = i + 1
                while j < m and s[j] == run_ch:
                    j += 1
                run_len = j - i
                if run_len >= 2:
                    cost = 1 + vlen(run_len) + 1 + dp[j]
                    if cost < best:
                        best = cost

                pat_lim = m - i
                if pat_lim > max_pat:
                    pat_lim = max_pat
                for p in range(1, pat_lim + 1):
                    base = s[i:i + p]
                    reps = 1
                    pos = i + p
                    while pos + p <= m and s[pos:pos + p] == base:
                        reps += 1
                        pos += p
                    if reps >= 2:
                        inner = period_cost(base)
                        cost = 1 + vlen(p) + inner + vlen(reps) + dp[pos]
                        if cost < best:
                            best = cost

                dp[i] = best
            return dp[0]

        periodic = period_cost(data)
        lz = lz_cost_and_verify(data)
        if lz is None:
            return 999.0
        hybrid = hybrid_block_cost(data)

        best = periodic
        if lz < best:
            best = lz
        if hybrid < best:
            best = hybrid

        ratio = best / n
        return float(ratio)
    except:
        return 999.0