diff --git a/CLAUDE.md b/CLAUDE.md index 80ea817..bb1fcfe 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -162,7 +162,7 @@ sull'hold-out; cambiarne le soglie guardando l'esito, pure. | gate | data | criterio | stato | |---|---|---|---| | **STATARB** | 2026-09-27 | soglie 24/07 (non toccate) + diagnostica statica sempre-short | ✅ monitor riparato e rigenerato il 26/08: la serie vera da' Sharpe **−1,61** a oggi → coi criteri invariati punta al **RITIRO**. Si legge il 27/09, non prima | -| **XSR01** | 2026-10-23 | Sharpe ≥1,0 **E** haircut a $5.000 ≤40% (se sfonda → ritiro a prescindere), poi `weights_tilt_null` e capitale ≥$5k | 🚨 legge un monitor **mal tarato** (§5.3), e P(capitale ≥$5k quel giorno) = **0,0%** (mediana $2.635) → **il criterio di capitale non e' raggiungibile**. Sotto la lente RENDITA il sleeve e' **eguagliato da un conto remunerato** (📌 sotto) | +| **XSR01** | 2026-10-23 | Sharpe ≥1,0 **E** haircut ≤40% — dal 26/08 il numero decisivo e' `r0826_xsr_haircut.py` a **pavimento $10**, citato con la frazione di ordini eseguiti — poi `weights_tilt_null` e **capitale ≥$20k** | ✅ **riscritto il 26/08 su decisione dell'operatore** (dichiarato prima dell'esito, stringe: diario `2026-08-26-xsr01-gate-riscritto`): capitale allineato a "100% Deribit fino a $20k"; serie forward rigenerata (31 barre vere, Sharpe −2,72). Sotto la lente RENDITA il sleeve resta **eguagliato da un conto remunerato** (📌 sotto) | | **DVOLSPREAD** | kill 2026-10-24 se Sh<−0,50; decisione 2027-01-24 | (a) Sharpe>0 (b) marginale ADDS+robust_oos+insample_edge (c) **DSR ≥0,95** (d) `weights_tilt_null`; **veto** se barre attive <80% → si estende, non si decide | ✅ serie rigenerata il 26/08 (−4,41 a oggi, era −14,73 sulla serie rotta); il veto barre-attive ora conta barre VERE e la guardia PREMATURO sorveglia il monitor | | **GATE PROP-01** | chiuso 22-23/08 | (a) listino 13/13 ✅ (b) ancora SKH01 23/23 ✅ (c) economica+sopravvivenza 2/2 ✅ | **chiuso 3/3** — ma il numero operativo e' sceso 42% → 7,8% → 4,4% → 2,6% | | **GATE PREVDAY-01** | scritto 23/08 | 10 condizioni | **8/10**: la cella che GIRA non e' quella che la selezione onesta sceglie, e quella viva **fallisce il DSR** (0,905) | @@ -197,10 +197,12 @@ d'ancora in modo diverso (nella differenza si cancella in parte, nel livello per ingoiato. **Resta:** `alerted=True` marcato **prima** dell'invio → un 🚨 perso e' perso per l'episodio intero (gli episodi storici durano 200-2.324 ore). Cambiarlo **cambia il comportamento** → decisione dell'operatore. -3. 🚨 **Il gate XSR01 del 23/10 legge un monitor tarato sul pavimento del venue sbagliato** - (C* vero $15.000-20.000, non ~$3.000). Due sole vie pulite: riscrivere la soglia **adesso** - dichiarando che la si riscrive prima di vedere l'esito, **oppure** lasciarla e **citare il difetto - alla decisione**. Decisione dell'operatore. +3. ✅ **RISOLTO (2026-08-26, decisione dell'operatore: opzione "riscrivere adesso").** Gate + XSR01 riscritto in modo dichiarato, prima dell'esito, in direzione che stringe: capitale + $5k → **$20k** (riconcilia con la decisione 26/07, che e' posteriore e governa), gamba haircut + letta da `r0826_xsr_haircut.py` a pavimento $10 con la frazione di ordini eseguiti accanto + (misurata: haircut FULL −1,1% con **22% di eseguiti** — la guardia da sola era vacua), soglie + numeriche INVARIATE. Diario `2026-08-26-xsr01-gate-riscritto.md`. 4. ❓ **Due domande al commercialista, aperte** (valgono ~$22k di muro e ~€30/mese di versamento): (a) i derivati Deribit (inverse, margine e regolamento in cripto, sede extra-UE) stanno in `c-sexies` (33%) o `c-quater` (26%)? E il collaterale sconta il 2‰ al 31/12? (b) i payout di una diff --git a/docs/diary/2026-08-26-xsr01-gate-riscritto.md b/docs/diary/2026-08-26-xsr01-gate-riscritto.md new file mode 100644 index 0000000..adf4f2f --- /dev/null +++ b/docs/diary/2026-08-26-xsr01-gate-riscritto.md @@ -0,0 +1,44 @@ +# 2026-08-26 — Gate XSR01 (23/10): riscrittura DICHIARATA, decisa dall'operatore + +**Decisione dell'operatore** (oggi, discussione in sessione): opzione **A** fra le tre proposte — +riscrivere ora il gate, dichiarandolo, invece di lasciarlo e citare i difetti (B) o ritirare +XSR01 in anticipo (C, che avrebbe violato la pre-registrazione). + +Il docstring del gate prescrive: *"ogni modifica va motivata nel diario come violazione"*. +Questa e' quella motivazione. **Scritta a 58 giorni dalla decisione, prima di vederne l'esito, +e in direzione che STRINGE i criteri** — le tre proprieta' che rendono una riscrittura +difendibile invece che selection-on-forward. + +## Le tre modifiche + +1. **Capitale per il deploy: $5.000 → $20.000.** Non e' tuning: il gate fu scritto il 25/07, + e il 26/07 l'operatore ha preso la decisione vincolante *"100% Deribit fino a $20k"* — + posteriore, quindi governa (M28: quando due impegni si contraddicono, la contraddizione e' + informazione). Il criterio a $5k autorizzava capitale su Hyperliquid che un'altra decisione + gia' vietava. Ora il deploy di XSR01 e la riapertura della scelta del venue coincidono a + $20k: **una decisione sola, un punto solo**. +2. **Gamba haircut: il numero decisivo viene da uno script committato** — + `r0826_xsr_haircut.py` (N11: il "$14,41" dell'ammissione non aveva script ed era ~2,4x + ottimista), **a pavimento $10** (il pavimento vero misurato da HL-EXEC; il libro REAL-$5000 + del monitor gira a $5 ed e' ottimista per costruzione), **citato accanto alla frazione di + ordini eseguiti** (P7). Misurato oggi, ed e' la conferma empirica del difetto dello + strumento: sul FULL a pavimento $10 l'haircut e' **−1,1%** con **il 22% di ordini + eseguiti** — la guardia non puo' quasi scattare per costruzione, perche' un libro che non + si muove ha haircut piccolo. **La soglia resta il 40% pre-registrato: nessuna soglia nuova + viene scritta oggi coi dati in mano.** +3. **Contesto corretto:** il riferimento `IS_SHARPE_NET = 1.82` era una terza lente + (XSR-REPRO): ora cita **1,79**, lente dei gate alla scoperta. Il criterio non cambia. + +## I numeri di oggi (58 giorni alla decisione — NON decidono niente) + +- forward rigenerato (serie vera dal 26/08): **31 barre, Sharpe −2,72**, maxDD 0,8% +- ticket per gamba a $5.000: mediano **$3,34**, medio $5,99, 63% sotto $5, **84% sotto $10** + (46.200 ordini replay) — riproduce XSR-REPRO e sostituisce il $14,41 +- haircut forward a pavimento $10: −10,7% (dentro la guardia), **ordini eseguiti 38%** +- FULL 968 barre: MODELED Sharpe 2,12; floor $10 → haircut −1,1%, eseguiti **22%** + +## Cosa riaprirebbe XSR01 (registrato qui perche' non vada riscoperto) + +Capitale ≥$60k (per un 25% sopra C\*) · un venue con C\* più basso di $15-20k · una misura che +mostri nel meccanismo qualcosa oltre la coppia (media, vol) — il null del 25/08 +(`r0825_xsr_rendita.py`) ha detto che oggi non c'e'. diff --git a/docs/memory/10-sleeve-e-candidati.md b/docs/memory/10-sleeve-e-candidati.md index fc17e28..ef4433d 100644 --- a/docs/memory/10-sleeve-e-candidati.md +++ b/docs/memory/10-sleeve-e-candidati.md @@ -315,15 +315,20 @@ Ogni numero va letto con la sua banda d'ancora e la sua lente. con turnover 38.5% del lordo/g su 50 alt anche illiquidi e **slippage NON modellato** (rischio #1). **Eseguibilita':** ticket/gamba $1.73 a $600 (**sotto min-order $5 → STAT-MODE oggi**), $5.76 a $2000, **$14.41 a $5000** → diventa reale a **~$5k**, non ai ~$20k di XS01. - 🚨 **IL GATE QUI SOTTO LEGGE UN MONITOR MAL TARATO (misurato 2026-08-23, §67): il pavimento del - venue usato per l'haircut e' quello sbagliato — C\* vero $15.000-20.000, non i ~$3.000 riportati da - HL-EXEC con un criterio piu' permissivo.** Le soglie **NON sono state toccate**: cambiarle guardando - questa misura a due mesi dalla decisione sarebbe selection-on-holdout. Le due vie pulite: riscriverle - **adesso** dichiarando che le si riscrive prima di vedere l'esito, oppure lasciarle e **citare il - difetto al momento della decisione**. **Decisione dell'operatore.** - **Gate pre-registrato 2026-10-23** (forward-day 0): deploy solo se Sharpe≥1.0 **E** haircut di - eseguibilita' a $5000 ≤40% (se l'haircut sfonda → **RITIRO a prescindere dallo Sharpe**), poi - weights_tilt_null e capitale ≥$5k. Monitor in `cron_daily.sh`, 3 libri (MODELED $2000 / REAL $600 / + ✅ **GATE RISCRITTO IL 2026-08-26 (decisione dell'operatore, opzione A: riscrivere adesso, + dichiarandolo — diario `2026-08-26-xsr01-gate-riscritto.md`).** A 58 giorni dalla decisione, + prima dell'esito, in direzione che stringe: (1) **capitale deploy $5k → $20k** — il gate del + 25/07 contraddiceva la decisione vincolante "100% Deribit fino a $20k" del 26/07, posteriore, + che governa (M28); ora deploy XSR01 e scelta del venue coincidono in UN punto; (2) gamba + haircut letta da **`r0826_xsr_haircut.py`** (N11) a **pavimento $10** (il vero, HL-EXEC) con + la **frazione di ordini eseguiti** accanto (P7) — misurato: FULL 968 barre, floor $10 → + haircut **−1,1%** con **22% di eseguiti**: la guardia da sola era vacua (un libro fermo ha + haircut piccolo); ticket mediano **$3,34**/gamba, 84% sotto $10 — riproduce XSR-REPRO e + sostituisce il "$14,41" senza script; (3) contesto 1.82 → 1.79 (lente dei gate). **Soglie + numeriche INVARIATE** (Sharpe 1,0/0,3; haircut 40%): nessuna soglia nuova coi dati in mano. + **Gate pre-registrato 2026-10-23** (forward-day 0): deploy solo se Sharpe≥1.0 **E** haircut + ≤40% (strumento onesto di cui sopra; se sfonda → **RITIRO a prescindere dallo Sharpe**), poi + weights_tilt_null e **capitale ≥$20k**. Monitor in `cron_daily.sh`, 3 libri (MODELED $2000 / REAL $600 / REAL $5000). ⚠ Lezione: XSR01 **non e' nato da un'idea nuova ma dalla DIAGNOSI di un fallimento** (ampiezza effettiva 4.5 → c'e' un fattore comune da togliere); e i suoi null vanno confrontati **a fee zero**, perche' permutare un segnale ne fa esplodere il turnover e il null perderebbe per diff --git a/scripts/research/r0725_xsr_deploy_gate.py b/scripts/research/r0725_xsr_deploy_gate.py index 5063ae1..054ec22 100644 --- a/scripts/research/r0725_xsr_deploy_gate.py +++ b/scripts/research/r0725_xsr_deploy_gate.py @@ -11,6 +11,23 @@ deflated-Sharpe 0.985, corr ~0 a tutti e 5 gli sleeve. Sopravvive a tre null fee test di lag. NON e' nel book per tre motivi dichiarati: storia corta e monotona crescente, `weights_tilt_null` fallito, e margine di costo sottile con slippage NON modellato. +⚠️ MODIFICA DICHIARATA 2026-08-26 (diario `2026-08-26-xsr01-gate-riscritto.md`) — decisa +dall'operatore PRIMA di vedere l'esito, a 58 giorni dalla data, e in direzione che STRINGE: + 1. CAPITALE per il deploy: $5.000 -> $20.000. Non e' tuning sull'esito: riconcilia il gate + (scritto il 25/07) con la decisione vincolante "100% Deribit fino a $20k" (26/07), che e' + POSTERIORE e lo governa — sotto $20k nessun capitale esce da Deribit, quindi il criterio + a $5k autorizzava una cosa che un'altra decisione gia' vietava (M28). + 2. GAMBA HAIRCUT: il numero decisivo alla decisione e' quello dello script committato + `r0826_xsr_haircut.py` a pavimento $10 (il pavimento VERO misurato, HL-EXEC 22/08 — il + libro REAL-$5000 del monitor gira a $5 ed e' ottimista per costruzione), CITATO ACCANTO + alla frazione di ordini eseguiti (P7): a $10 si esegue ~1 ordine su 5, e un haircut + piccolo con pochi ordini eseguiti non e' eseguibilita', e' un libro fermo. La SOGLIA + resta il 40% pre-registrato: nessuna soglia nuova viene scritta oggi coi dati in mano. + 3. Il riferimento "in-sample 1.82" era una TERZA lente (XSR-REPRO 22/08): la lente dei gate + da' 1.79 alla scoperta. Corretto il contesto, non il criterio. +La serie forward e' quella RIGENERATA il 26/08 (advance() riparato, §5.1): stessa finestra, +stesso forward-day 0, barre finalmente VERE. + REGOLA (immutabile — ogni modifica va motivata nel diario come violazione): - Data decisione: 2026-10-23 (90 giorni forward dal 2026-07-25). Non prima. - Metrica primaria: Sharpe annualizzato di `net_modeled` su TUTTA la finestra forward. @@ -22,7 +39,7 @@ REGOLA (immutabile — ogni modifica va motivata nel diario come violazione): - Esiti: Sharpe >= 1.0 AND haircut$5000 <= 40% -> CANDIDATO SLEEVE: proporre peso {5,10}% e giudicarlo con `weights_tilt_null` (che oggi NON passa) + maxDD combinato. - Deploy solo se il tilt-null passa E il capitale e' >= $5000. + Deploy solo se il tilt-null passa E il capitale e' >= $20.000 (mod. 26/08). 0.3 <= Sh < 1.0 -> ESTENDI una sola volta di 90g (2027-01-21). Sharpe < 0.3 OR haircut > 40% -> RITIRO dal forward-monitor. - Guardie accessorie: config invariata (il test `tests/test_paper_xsr.py` la blocca); @@ -47,7 +64,8 @@ DECISION_EXT = date(2027, 1, 21) SH_DEPLOY = 1.0 SH_RETIRE = 0.3 HAIRCUT_MAX = 0.40 -IS_SHARPE_NET = 1.82 # riferimento in-sample, per contesto +CAPITALE_DEPLOY = 20_000.0 # mod. dichiarata 26/08: riconcilia col muro "100% Deribit" (26/07) +IS_SHARPE_NET = 1.79 # lente dei gate alla scoperta (il "1.82" era una terza lente) def main() -> None: @@ -78,7 +96,10 @@ def main() -> None: print(f" Sharpe fwd (mod) : {sh:+.2f} (in-sample netta era {IS_SHARPE_NET:.2f})") print(f" maxDD fwd : {dd:.1%}") print(f" ritorno MODELED : {tot_m*100:+.2f}% REAL-$5000: {tot_5*100:+.2f}%") - print(f" haircut eseguib. : {haircut*100:.1f}% (guardia <= {HAIRCUT_MAX*100:.0f}%)") + print(f" haircut monitor : {haircut*100:.1f}% (pavimento $5 — ottimista per costruzione)") + print(f" guardia <= {HAIRCUT_MAX*100:.0f}%: il numero DECISIVO e' quello di " + f"`r0826_xsr_haircut.py` a pavimento $10,") + print( " citato accanto alla frazione di ordini eseguiti (mod. 26/08)") print(f" data decisione : {DECISION} (proroga unica: {DECISION_EXT})") if today < DECISION: @@ -89,7 +110,8 @@ def main() -> None: print("\n -> RITIRO: l'haircut di eseguibilita' supera la guardia. E' costo, non edge.") elif sh >= SH_DEPLOY: print("\n -> CANDIDATO SLEEVE: proporre peso {5,10}% e passarlo a weights_tilt_null " - "(oggi NON passa) + maxDD combinato. Deploy solo con capitale >= $5000.") + f"(oggi NON passa) + maxDD combinato. Deploy solo con capitale >= " + f"${CAPITALE_DEPLOY:,.0f} (mod. 26/08, allineato a '100% Deribit fino a $20k').") elif sh >= SH_RETIRE: print(f"\n -> SOTTO SOGLIA ma >= {SH_RETIRE}: estensione unica fino al {DECISION_EXT}.") else: diff --git a/scripts/research/r0826_xsr_haircut.py b/scripts/research/r0826_xsr_haircut.py new file mode 100644 index 0000000..e5ac87b --- /dev/null +++ b/scripts/research/r0826_xsr_haircut.py @@ -0,0 +1,139 @@ +"""r0826_xsr_haircut.py — l'haircut di eseguibilita' di XSR01 a $5.000, MISURATO con uno script. + +PERCHE' ESISTE. La seconda gamba del gate XSR01 (23/10) e' "haircut a $5.000 <= 40%", ma: + (a) il numero pubblicato all'ammissione ($14,41 di ticket/gamba) NON ha uno script committato + che lo riproduca ed e' ~2,4x ottimista (XSR-REPRO 22/08: mediano vero $3,33/gamba); + (b) il libro REAL-$5000 del monitor gira con pavimento $5, ma il pavimento VERO misurato del + venue e' $10 (HL-EXEC 22/08) — e a $10 si esegue ~1 ordine su 5; + (c) il paradosso dello strumento: con POCHI ordini eseguiti il libro reale resta vicino al + modellato nei periodi calmi -> l'haircut misurato dal monitor puo' sembrare piccolo + proprio quando l'eseguibilita' e' pessima. La frazione di ordini eseguiti va letta + ACCANTO all'haircut, mai al suo posto (P7: uno "zero" si legge accanto alla quota di + campione utilizzabile). + +COSA FA. Replay dei libri XSR01 col codice di PRODUZIONE (`paper_xsr._step`, nessuna +reimplementazione — il metodo dell'audit 22/08), capitale $5.000, pavimenti $5 e $10, su due +finestre: FULL (tutte le barre chiuse, ~2,6 anni: la risoluzione) e FORWARD (dal forward-day 0 +del gate, 2026-07-25: cio' che il gate legge). Sole barre CHIUSE (paper_guard). + +E' lo script che il gate del 23/10 cita come strumento DECISIVO per la gamba haircut +(modifica dichiarata del 2026-08-26, diario `2026-08-26-xsr01-gate-riscritto.md`). + + uv run python scripts/research/r0826_xsr_haircut.py +""" +from __future__ import annotations + +import importlib.util +import json +import sys +from pathlib import Path + +import numpy as np +import pandas as pd + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT)) + +from src.live.paper_guard import MS_1D, nuove_chiuse # noqa: E402 + +CAP = 5_000.0 +PAVIMENTI = (5.0, 10.0) # $5 = il pavimento del monitor · $10 = il pavimento VERO (HL-EXEC) +ANN = float(np.sqrt(365.0)) + + +def _px(): + spec = importlib.util.spec_from_file_location("_hx_paper_xsr", + ROOT / "scripts" / "live" / "paper_xsr.py") + m = importlib.util.module_from_spec(spec) + spec.loader.exec_module(m) + return m + + +def _sh(r: np.ndarray) -> float: + return float(r.mean() / r.std() * ANN) if len(r) > 1 and r.std() > 0 else float("nan") + + +def replay(px, idx: list[int], W, R, rb, n_gambe: int, min_order: float | None) -> dict: + bk = px._book(CAP, n_gambe) + net = [] + for i in idx: + net.append(px._step(bk, W[i], R[i], float(rb[i]), min_order)) + net = np.asarray(net) + tot = float(np.prod(1 + net) - 1) + n_ordini = bk["n_fill"] + bk["n_skip"] + return dict(net=net, tot=tot, sh=_sh(net), + frazione_eseguita=(bk["n_fill"] / n_ordini if n_ordini else float("nan"))) + + +def misura(px, idx: list[int], W, R, rb, n_gambe: int) -> dict: + """Per una finestra: MODELED + un libro reale per pavimento, con l'haircut del gate.""" + out = dict(modeled=replay(px, idx, W, R, rb, n_gambe, None)) + tot_m = out["modeled"]["tot"] + for f in PAVIMENTI: + r = replay(px, idx, W, R, rb, n_gambe, f) + r["haircut"] = (tot_m - r["tot"]) / abs(tot_m) if tot_m != 0 else float("nan") + out[f] = r + return out + + +def ticket_stats(W, idx: list[int]) -> dict: + """Taglia degli ordini per gamba a $5.000: |Δw| x capitale a ogni ribilancio.""" + t = [] + prev = np.zeros(W.shape[1]) + for i in idx: + w = np.nan_to_num(W[i]) + d = np.abs(w - prev) * CAP + t.extend(d[d > 0].tolist()) + prev = w + t = np.asarray(t) + return dict(mediano=float(np.median(t)), medio=float(np.mean(t)), + sotto5=float((t < 5.0).mean()), sotto10=float((t < 10.0).mean()), n=len(t)) + + +def main() -> None: + print("=" * 96) + print(f" XSR01 — haircut di eseguibilita' a ${CAP:,.0f}, replay col codice di produzione") + print("=" * 96) + px = _px() + ts, dt, W, R, rb, syms = px.build_panel() + st = json.loads((ROOT / "data" / "paper_xsr" / "state.json").read_text()) + chiuse = nuove_chiuse(ts, 0, MS_1D) + fwd = [i for i in chiuse if ts[i] > st["start_ts"]] + Wv = np.nan_to_num(np.asarray(W, float)) + Rv = np.nan_to_num(np.asarray(R, float)) + + tk = ticket_stats(Wv, chiuse) + print(f"\n TICKET PER GAMBA a ${CAP:,.0f} (riproduce/sostituisce il '$14,41' senza script):") + print(f" mediano ${tk['mediano']:.2f} · medio ${tk['medio']:.2f} · " + f"sotto $5: {tk['sotto5']:.0%} · sotto $10: {tk['sotto10']:.0%} " + f"({tk['n']:,} ordini su {len(chiuse)} barre)") + + for nome, idx in (("FULL (tutte le barre chiuse)", chiuse), ("FORWARD (dal 2026-07-25)", fwd)): + if len(idx) < 5: + print(f"\n {nome}: {len(idx)} barre — troppo corta, nessun numero") + continue + m = misura(px, idx, Wv, Rv, rb, len(syms)) + print(f"\n {nome} — {len(idx)} barre " + f"({pd.Timestamp(int(ts[idx[0]]), unit='ms', tz='UTC').date()} -> " + f"{pd.Timestamp(int(ts[idx[-1]]), unit='ms', tz='UTC').date()})") + print(f" {'libro':<18} {'tot':>9} {'Sharpe':>8} {'haircut':>9} {'ordini eseguiti':>17}") + print(" " + "-" * 66) + print(f" {'MODELED':<18} {m['modeled']['tot']:>8.2%} {m['modeled']['sh']:>8.2f} " + f"{'—':>9} {'—':>17}") + for f in PAVIMENTI: + r = m[f] + print(f" {'REAL floor $%.0f' % f:<18} {r['tot']:>8.2%} {r['sh']:>8.2f} " + f"{r['haircut']:>8.1%} {r['frazione_eseguita']:>16.0%}") + if nome.startswith("FORWARD"): + h10 = m[10.0]["haircut"] + fe10 = m[10.0]["frazione_eseguita"] + print(f"\n VERDETTO gate (gamba haircut, pavimento VERO $10): " + f"{h10:+.1%} contro guardia 40%" + f" -> {'SFONDA (RITIRO a prescindere)' if abs(h10) > 0.40 else 'dentro la guardia'}") + print(f" ⚠️ da leggere ACCANTO: ordini eseguiti {fe10:.0%} — un haircut piccolo " + f"con pochi ordini\n eseguiti non e' eseguibilita', e' un libro che non " + f"si muove (P7).") + + +if __name__ == "__main__": + main()