Widened the crop sweep to 30 angles x 25 offsets, paid for by radius-prefiltering the lattice using gauge(p) >= |p|; n=200 0.9715 -> 0.9825.

… 272 unchanged lines …
     return bx, by
 
 
-def _crop_lattices(n, keep):
-    """Undistorted lattices cropped by the container gauge to the tightest scaled copy."""
+def _crop_lattices(n, keep, t_end, nang, noff):
+    """Undistorted lattices cropped by the container gauge to the tightest scaled copy.
+
+    gauge(p) >= |p| always (the gauge equals the radius only where p points at a vertex),
+    so radius-filtering the raw lattice to the estimated crop scale keeps every point that
+    can make the cut.  That is what makes a fine angle/offset sweep affordable.
+    """
     out = []
     seen = set()
     area_pp = (0.8660254037844386, 1.0)
+    a1 = math.pi if not SIDES else 0.5 * SIDES * math.sin(2.0 * math.pi / SIDES)
     for bi, (u1, u2, v1, v2, maxrad) in enumerate((
-            (1.0, 0.0, 0.5, 0.8660254037844386, 0.5235987755982988),
-            (1.0, 0.0, 0.0, 1.0, 0.7853981633974483))):
-        # gauge radius that should hold about n points, with slack
-        half = math.sqrt(n * area_pp[bi]) * 0.5
-        lim = half * 2.0
-        rad = lim * 1.5 + 1.0
-        ra = int(rad * 2.3) + 3
+            (1.0, 0.0, 0.5, 0.8660254037844386, 1.0471975511965976),
+            (1.0, 0.0, 0.0, 1.0, 1.5707963267948966))):
+        g_est = math.sqrt(n * area_pp[bi] / a1)
+        rad = g_est * 1.18 + 1.7
+        ra = int(rad * 2.4) + 3
         raw = []
         for a in range(-ra, ra + 1):
             for b in range(-ra, ra + 1):
… 3 unchanged lines …
                     raw.append((x, y))
         if len(raw) < n:
             continue
-        nang = 14
         for ai in range(nang):
+            if time.perf_counter() >= t_end:
+                break
             th = maxrad * ai / nang
             c = math.cos(th)
             s = math.sin(th)
             rot = [(x * c - y * s, x * s + y * c) for x, y in raw]
-            for oi in range(3):
-                for oj in range(3):
-                    dx = (oi / 3.0) * u1 + (oj / 3.0) * v1
-                    dy = (oi / 3.0) * u2 + (oj / 3.0) * v2
+            for oi in range(noff):
+                for oj in range(noff):
+                    dx = (oi / noff) * u1 + (oj / noff) * v1
+                    dy = (oi / noff) * u2 + (oj / noff) * v2
                     sx = dx * c - dy * s
                     sy = dx * s + dy * c
                     keys = []
… 13 unchanged lines …
                     if key in seen:
                         continue
                     seen.add(key)
-                    f = 1.0 / g
-                    out.append((m, [(p[1] * f, p[2] * f) for p in keys[:n]]))
+                    out.append((m, [(p[1] * m, p[2] * m) for p in keys[:n]]))
     out.sort(key=lambda t: -t[0])
     return out[:keep]
 
… 31 unchanged lines …
     return out
 
 
-def _starts(n, keep, rng):
+def _starts(n, keep, rng, t_end, nang, noff):
     cell = max(1e-3, 1.4 / math.sqrt(n))
     cands = []
     seen = set()
-    for m, pts in _crop_lattices(n, keep):
+    for m, pts in _crop_lattices(n, keep, t_end, nang, noff):
         key = round(m, 9)
         if key not in seen:
             seen.add(key)
… 28 unchanged lines …
     tries = 300
     cell0 = max(1e-3, 1.4 / math.sqrt(n))
 
-    lats = _starts(n, 8, rng)
+    nang = 30 if n >= 60 else 18
+    noff = 5 if n >= 60 else 4
+    lats = _starts(n, 8, rng, t0 + time_budget * 0.16, nang, noff)
 
     best_xs = best_ys = None
     best_m = -1.0
… 57 unchanged lines …