Solution #c0d68d5c-fa9d-4207-bf1b-597f887e66e7

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

        raw = data.encode("utf-8")
        n = len(raw)
        if n == 0:
            return 0.0

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

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

        def lit_cost(l):
            return 1 + vbytes(l) + l

        def rle_cost(l):
            return 1 + 1 + vbytes(l)

        def ref_cost(d, l):
            return 1 + vbytes(d) + vbytes(l)

        min_match = 4
        max_window = min(n, 65535)

        next_same = [-1] * n
        last_pos = {}
        for i in range(n - 1, -1, -1):
            b = raw[i]
            next_same[i] = last_pos.get(b, -1)
            last_pos[b] = i

        best_len = [0] * n
        best_dist = [0] * n

        for i in range(n):
            if i + min_match > n:
                continue

            p = next_same[i]
            checked = 0
            bestl = 0
            bestd = 0

            while p != -1 and checked < 48:
                d = p - i
                if d > max_window:
                    break
                checked += 1

                if i + d + min_match <= n and raw[i:i + min_match] == raw[i + d:i + d + min_match]:
                    l = min_match
                    limit = n - i - d
                    while l < limit and raw[i + l] == raw[i + d + l]:
                        l += 1

                    total = d + l
                    while total < n and raw[i + total] == raw[i + total - d]:
                        total += 1

                    if total >= min_match:
                        c_ref = ref_cost(d, total)
                        c_lit = lit_cost(total)
                        if c_ref < c_lit and total > bestl:
                            bestl = total
                            bestd = d

                p = next_same[p]

            best_len[i] = bestl
            best_dist[i] = bestd

        INF = 10**18
        dp = [INF] * (n + 1)
        choice = [None] * (n + 1)
        dp[n] = 0

        max_lit = 128

        for i in range(n - 1, -1, -1):
            b = raw[i]

            run = 1
            while i + run < n and raw[i + run] == b:
                run += 1
            if run >= 4:
                cand = [run]
                if run > 8:
                    cand.append(4)
                    cand.append(run // 2)
                else:
                    cand.extend(range(4, run))
                seen = set()
                for l in cand:
                    if l < 4 or l > run or l in seen:
                        continue
                    seen.add(l)
                    c = rle_cost(l) + dp[i + l]
                    if c < dp[i]:
                        dp[i] = c
                        choice[i] = ("R", l)

            bl = best_len[i]
            if bl >= min_match:
                d = best_dist[i]
                cand = [bl, min_match]
                if bl >= 8:
                    cand.append(bl // 2)
                seen = set()
                for l in cand:
                    if l < min_match or l > bl or l in seen:
                        continue
                    seen.add(l)
                    c = ref_cost(d, l) + dp[i + l]
                    if c < dp[i]:
                        dp[i] = c
                        choice[i] = ("B", d, l)

            limit = min(max_lit, n - i)
            acc = 1 + vbytes(1)
            for l in range(1, limit + 1):
                if l > 1:
                    acc += 1
                c = acc + dp[i + l]
                if c < dp[i]:
                    dp[i] = c
                    choice[i] = ("L", l)

        out = bytearray()
        i = 0
        while i < n:
            ch = choice[i]
            if ch is None:
                return 999.0
            t = ch[0]
            if t == "L":
                l = ch[1]
                out.extend(raw[i:i + l])
                i += l
            elif t == "R":
                l = ch[1]
                out.extend(raw[i:i + 1] * l)
                i += l
            else:
                d, l = ch[1], ch[2]
                if d <= 0 or d > len(out):
                    return 999.0
                start = len(out) - d
                for k in range(l):
                    out.append(out[start + k])
                i += l

        if bytes(out) != raw:
            return 999.0

        ratio = dp[0] / float(original_size)
        if ratio < 0:
            return 999.0
        return float(ratio)
    except:
        return 999.0