Novità

Script da fare con calma

ciao the wolf e grazie per lo script interessante.


posso chiederti come sono da intendere esattamente
i valori espressi nel riepilogo

es: bari 67(177) cosa è il 67 e cosa è il 177 tra parentesi?


METODO PREVISIVO (Ritardo sulla massa numerica, per ruota)
Ritardo = estrazioni trascorse dall'ultima comparsa in un evento Q/C su quella ruota
--------------------------------------------------------------------------------
Bari | Top 10 ritardatari (dalla massa):
67(177) 84(155) 30(144) 32(144) 34(107) 58(106) 23(91) 06(81) 65(79) 28(67)
Cagliari | Top 10 ritardatari (dalla massa):
13(276) 32(256) 67(150) 08(137) 34(137) 82(123) 30(106) 62(101) 06(90) 36(83)
Firenze | Top 10 ritardatari (dalla massa):
46(161) 43(126) 16(107) 66(107) 37(96) 38(94) 76(89) 32(87) 48(77) 88(77)
Genova | Top 10 ritardatari (dalla massa):
87(206) 83(175) 03(138) 36(121) 65(116) 16(113) 31(86) 48(83) 37(74) 30(73)
Milano | Top 10 ritardatari (dalla massa):
38(169) 36(164) 78(137) 33(136) 67(132) 69(130) 06(128) 16(128) 39(126) 65(126)
Napoli | Top 10 ritardatari (dalla massa):
83(153) 35(119) 62(82) 86(80) 34(71) 37(64) 46(64) 43(61) 82(61) 13(47)
Palermo | Top 10 ritardatari (dalla massa):
53(241) 73(218) 30(176) 35(165) 32(161) 64(118) 66(116) 31(101) 63(101) 81(96)
Roma | Top 10 ritardatari (dalla massa):
48(228) 13(93) 83(93) 30(85) 32(67) 65(62) 53(60) 33(52) 76(52) 56(48)
Torino | Top 10 ritardatari (dalla massa):
03(153) 69(141) 37(140) 76(95) 63(93) 36(91) 89(85) 81(76) 06(68) 86(68)
Venezia | Top 10 ritardatari (dalla massa):
80(224) 39(170) 82(170) 88(119) 60(114) 69(91) 64(84) 68(75) 53(71) 48(70)
Tutte | Top 10 ritardatari (dalla massa):
03(7390) 06(7390) 08(7390) 13(7390) 16(7390) 18(7390) 23(7390) 26(7390) 28(7390) 30(7390)
--------------------------------------------------------------------------------
NB: il ritardo è calcolato SOLO sulle uscite in eventi di quaterna/cinquina.
 
buon pomeriggio vincenzo63, ecco il codice con la variante richiesta:
Sub Main
Dim es, r, p, i, a, b
Dim nTrovati, sNumeri, sEsito
Dim k, idNum, dec, cad
Dim sElenco, cTotEventi, rVera, nEstratto
Dim aTrovatiTemp(5)
Dim nTmpCount, jj
Dim tmpN, tmpF

' --- PARAMETRI DI CONFIGURAZIONE TRAMITE INPUTBOX ---
Dim sDecineScelte, sCadenzeScelte

' Richiesta interattiva delle decine
sDecineScelte = InputBox("Inserisci le decine da esaminare separate da virgola (es. 3, 6, 8):" & vbCrLf & "(0 per 1-9, 1 per 10-19, 2 per 20-29, 3 per 30-39, ecc.)", "Configurazione Decine", "3, 6, 8")
If VarType(sDecineScelte) = vbBoolean And sDecineScelte = False Then Exit Sub ' Gestione tasto Annulla

' Richiesta interattiva delle cadenze
sCadenzeScelte = InputBox("Inserisci le cadenze da esaminare separate da virgola (es. 3, 6, 8):", "Configurazione Cadenze", "3, 6, 8")
If VarType(sCadenzeScelte) = vbBoolean And sCadenzeScelte = False Then Exit Sub ' Gestione tasto Annulla
' ---------------------------------------------------

' Array di base (dichiarati dinamici per consentire il ridimensionamento pulito)
Dim aNumeri()
Dim aContaQ(11), aContaC(11)
Dim aFreqNum(90)

' --- Variabili per il metodo previsivo ---
Dim aUltimaUscita(11, 90)
Dim aRitardo(11, 90)
Dim nRuotaIdx, nNumIdx
Dim aTmpNum(), aTmpRit()
Dim tmpS, tmpNN
Dim sRiga, nLimit

' 1. Generazione automatica della massa dei numeri in base alle scelte
k = 0
ReDim aNumeri(90)

For idNum = 1 To 90
dec = CInt(idNum \ 10)
cad = idNum Mod 10

If VerificaFiltro(dec, cad, sDecineScelte, sCadenzeScelte) Then
k = k + 1
aNumeri(k) = idNum
End If
Next

' Ridimensiona gli array alla dimensione reale k
ReDim Preserve aNumeri(k)
ReDim aTmpNum(k)
ReDim aTmpRit(k)

If k = 0 Then
MsgBox "Attenzione: nessun numero soddisfa i criteri inseriti. Controlla le configurazioni.", vbCritical
Exit Sub
End If

' --- Inizializzazioni rapide ---
For i = 1 To 11
aContaQ(i) = 0
aContaC(i) = 0
Next

For i = 1 To 90
aFreqNum(i) = 0
Next

For i = 1 To 11
For jj = 1 To 90
aUltimaUscita(i, jj) = 0
Next
Next

' --- VISUALIZZAZIONE MASSA DEI NUMERI A MONTE ---
ColoreTesto 2
Scrivi "================================================================================"
Scrivi " MASSA NUMERICA DI ANALISI (Totale Numeri: " & k & ")"
Scrivi " Decine esaminate: [" & sDecineScelte & "] | Cadenze esaminate: [" & sCadenzeScelte & "]"
Scrivi "================================================================================"

sElenco = ""
For i = 1 To k
sElenco = sElenco & Format2(aNumeri(i)) & " "
If i Mod 24 = 0 Then
Scrivi sElenco
sElenco = ""
End If
Next
If sElenco <> "" Then Scrivi sElenco
Scrivi "--------------------------------------------------------------------------------"
ColoreTesto 1

Scrivi " STORICO EVENTI DI QUATERNA E CINQUINA"
Scrivi "--------------------------------------------------------------------------------"
Scrivi " N. | Data | Ruota | Esito | Numeri Sortiti"
Scrivi "--------------------------------------------------------------------------------"

cTotEventi = 0

' 2. Scansione dell'archivio storico
For es = 3549 To EstrazioniArchivio

If ScriptInterrotto Then
ColoreTesto 2
Scrivi "--------------------------------------------------------------------------------"
Scrivi "--> Elaborazione interrotta dall'utente.", True
Exit Sub
End If

For r = 1 To 12
If r <> 11 Then
rVera = r
If r = 12 Then rVera = 11

nTrovati = 0
sNumeri = ""
nTmpCount = 0

For p = 1 To 5
nEstratto = Estratto(es, rVera, p)

If Sme_InVettore(nEstratto, aNumeri) Then
nTrovati = nTrovati + 1
sNumeri = sNumeri & Format2(nEstratto) & " "
nTmpCount = nTmpCount + 1
aTrovatiTemp(nTmpCount) = nEstratto
End If
Next

If nTrovati >= 4 Then
cTotEventi = cTotEventi + 1
If nTrovati = 4 Then
sEsito = "QUATERNA"
aContaQ(rVera) = aContaQ(rVera) + 1
Else
sEsito = "CINQUINA"
aContaC(rVera) = aContaC(rVera) + 1
End If

For jj = 1 To nTmpCount
aFreqNum(aTrovatiTemp(jj)) = aFreqNum(aTrovatiTemp(jj)) + 1
aUltimaUscita(rVera, aTrovatiTemp(jj)) = es
Next

Scrivi FormatSpace(cTotEventi, 4, True) & " | " & _
DataEstrazione(es) & " | " & _
FormatSpace(NomeRuota(rVera), 10, False) & " | " & _
FormatSpace(sEsito, 8, False) & " | " & _
sNumeri
End If
End If
Next
Next

' --- RIEPILOGO PER RUOTA ---
ColoreTesto 2
Scrivi "--------------------------------------------------------------------------------"
Scrivi " RIEPILOGO FREQUENZE PER RUOTA (Quaterne / Cinquine)"
Scrivi "--------------------------------------------------------------------------------"
For i = 1 To 11
Scrivi FormatSpace(NomeRuota(i), 10, False) & " | Quaterne: " & aContaQ(i) & _
" | Cinquine: " & aContaC(i) & " | Totale: " & (aContaQ(i) + aContaC(i))
Next

' --- RIEPILOGO FREQUENZA SINGOLI NUMERI ---
Scrivi "--------------------------------------------------------------------------------"
Scrivi " FREQUENZA DEI NUMERI DELLA MASSA ALL'INTERNO DEGLI EVENTI Q/C (ordinati)"
Scrivi "--------------------------------------------------------------------------------"

For i = 1 To k
aTmpNum(i) = aNumeri(i)
aTmpRit(i) = aFreqNum(aNumeri(i))
Next

For a = 1 To k - 1
For b = 1 To k - a
If aTmpRit(b) < aTmpRit(b + 1) Then
tmpS = aTmpRit(b) : aTmpRit(b) = aTmpRit(b + 1) : aTmpRit(b + 1) = tmpS
tmpNN = aTmpNum(b) : aTmpNum(b) = aTmpNum(b + 1) : aTmpNum(b + 1) = tmpNN
End If
Next
Next

For i = 1 To k
Scrivi FormatSpace(Format2(aTmpNum(i)), 4, False) & " | Presenze in eventi Q/C: " & aTmpRit(i)
Next

Scrivi "--------------------------------------------------------------------------------"
Scrivi "Scansione completata. Totale eventi trovati: " & cTotEventi
ColoreTesto 0

' --- METODO PREVISIVO: RITARDO SULLA MASSA, PER RUOTA ---
ColoreTesto 2
Scrivi "--------------------------------------------------------------------------------"
Scrivi " METODO PREVISIVO (Ritardo sulla massa numerica, per ruota)"
Scrivi " Ritardo = estrazioni trascorse dall'ultima comparsa in un evento Q/C su quella ruota"
Scrivi "--------------------------------------------------------------------------------"
ColoreTesto 1

For nRuotaIdx = 1 To 11

For i = 1 To k
nNumIdx = aNumeri(i)
If aUltimaUscita(nRuotaIdx, nNumIdx) = 0 Then
aRitardo(nRuotaIdx, nNumIdx) = EstrazioniArchivio - 3549 + 1
Else
aRitardo(nRuotaIdx, nNumIdx) = EstrazioniArchivio - aUltimaUscita(nRuotaIdx, nNumIdx)
End If
Next

For i = 1 To k
aTmpNum(i) = aNumeri(i)
aTmpRit(i) = aRitardo(nRuotaIdx, aNumeri(i))
Next

For a = 1 To k - 1
For b = 1 To k - a
If aTmpRit(b) < aTmpRit(b + 1) Then
tmpS = aTmpRit(b) : aTmpRit(b) = aTmpRit(b + 1) : aTmpRit(b + 1) = tmpS
tmpNN = aTmpNum(b) : aTmpNum(b) = aTmpNum(b + 1) : aTmpNum(b + 1) = tmpNN
End If
Next
Next

Scrivi FormatSpace(NomeRuota(nRuotaIdx), 10, False) & " | Top 10 ritardatari (dalla massa): "
sRiga = " "
If k < 10 Then nLimit = k Else nLimit = 10

For i = 1 To nLimit
sRiga = sRiga & Format2(aTmpNum(i)) & "(" & aTmpRit(i) & ") "
Next
Scrivi sRiga

Next

Scrivi "--------------------------------------------------------------------------------"
Scrivi "NB: il ritardo è calcolato SOLO sulle uscite in eventi di quaterna/cinquina."
ColoreTesto 0
End Sub

' --- FUNZIONI DI SUPPORTO ---

Function Sme_InVettore(n, aVett)
Dim i
Sme_InVettore = False
For i = 1 To UBound(aVett)
If aVett(i) = n Then
Sme_InVettore = True
Exit Function
End If
Next
End Function

Function VerificaFiltro(dec, cad, sDec, sCad)
Dim bDecTrovata, bCadTrovata
Dim aD, aC, j

bDecTrovata = False
bCadTrovata = False

If Trim(sDec) <> "" Then
aD = Split(sDec, ",")
For j = 0 To UBound(aD)
If CInt(Trim(aD(j))) = dec Then
bDecTrovata = True
Exit For
End If
Next
End If

If Trim(sCad) <> "" Then
aC = Split(sCad, ",")
For j = 0 To UBound(aC)
If CInt(Trim(aC(j))) = cad Then
bCadTrovata = True
Exit For
End If
Next
End If

VerificaFiltro = (bDecTrovata Or bCadTrovata)
End Function
Grazie Wolf, una prospettiva da considerare come supporto di confronto,. ci sono ulteriori sviluppi da approfondire ...curiosità....ad esempio ..chissà che succede con la presenza in soli terni e quartine ?, o anche in coppie e terzine..sarebbe un ulteriore utile strumento di rappresentazione dei numeri.... buonanotte
 
Ultima modifica:
buona giornata

se vi può interessare, massimi ritardi del periodo esaminato
 

Allegati

  • Screenshot 2026-10-07 091518.png
    Screenshot 2026-10-07 091518.png
    17,7 KB · Visite: 15
  • Screenshot 2026-10-07 091535.png
    Screenshot 2026-10-07 091535.png
    17,7 KB · Visite: 12
  • Screenshot 2026-10-07 091737.png
    Screenshot 2026-10-07 091737.png
    18,1 KB · Visite: 9
  • Screenshot 2026-10-07 091840.png
    Screenshot 2026-10-07 091840.png
    22,5 KB · Visite: 8
  • Screenshot 2026-10-07 092109.png
    Screenshot 2026-10-07 092109.png
    22,8 KB · Visite: 9
  • Screenshot 2026-10-07 092205.png
    Screenshot 2026-10-07 092205.png
    23 KB · Visite: 19
Ultima modifica:
Grazie Wolf, una prospettiva da considerare come supporto di confronto,. ci sono ulteriori sviluppi da approfondire ...curiosità....ad esempio ..chissà che succede con la presenza in soli terni e quartine ?, o anche in coppie e terzine..sarebbe un ulteriore utile strumento di rappresentazione dei numeri.... buonanotte
Riepiloghi e Statistiche

  • Riepilogo per Ruota: Mostra il totale delle quaterne e cinquine verificate su ciascuna ruota.
  • Frequenza dei Singoli Numeri: Ordina e stampa i numeri della massa in base alle loro presenze complessive all'interno degli eventi di quaterna/cinquina.
  • Metodo Previsivo (Ritardo per Ruota): Calcola il ritardo attuale di ciascun numero della massa (espresso in numero di concorsi trascorsi dall'ultima apparizione in un evento Q/C su quella specifica ruota) e restituisce la Top 10 dei ritardatari per ogni ruota.
 
se può servire, una ruota GENOVA che in 3 colpi dovrebbe dare il terno o qualcosa in piu'

come si può vedere la formula 1.5.6 (rossa) e anche la 1.4.6 poco piu' sopra dovrebbero sfornare almeno il terno nei 48 numeri

in comune hanno decine e cadenze 1.6


Screenshot 2026-10-08 083023.png
 
su CAGLIARI ho trovato questa formula decine-cadenze (48 numeri x quaterna)
pochi colpi e potrebbe dare una quaterna


1791473667149.png
 
se può servire, una ruota GENOVA che in 3 colpi dovrebbe dare il terno o qualcosa in piu'

come si può vedere la formula 1.5.6 (rossa) e anche la 1.4.6 poco piu' sopra dovrebbero sfornare almeno il terno nei 48 numeri

in comune hanno decine e cadenze 1.6


Vedi l'allegato 2321857


solo per dire o segnalare che a genova ha dato addirittura 5 numeri (cinquina) questa lunghetta 48 numeri, non giocabili per il costo, ma 16 31 63 64 68

buona serata
 
Sono un tipo molto pigro e quindi non ho nessuna voglia di ripetere tante volte la parola Dim, End If, Next quindi scrivo in Python

SCRIPT_INTERROTTO = False
ESTRAZIONI_ARCHIVIO = 0 # <-- impostare con il numero reale di estrazioni
ARCHIVIO = {} # esempio: {3549: {1: [1,2,3,4,5], ...}, ...}


def estratto(es, ruota, pos):
"""Restituisce il numero estratto. pos è 1-based."""
return ARCHIVIO[es][ruota][pos - 1]


def data_estrazione(es):
"""Restituisce la data dell'estrazione come stringa."""
return f"Data({es})"


def nome_ruota(r):
nomi = {
1: "Bari", 2: "Cagliari", 3: "Firenze", 4: "Genova",
5: "Milano", 6: "Napoli", 7: "Palermo", 8: "Roma",
9: "Torino", 10: "Venezia", 11: "Nazionale"
}
return nomi.get(r, f"Ruota{r}")


def format2(n):
return f"{int(n):02d}"


def format_space(valore, larghezza, allinea_a_destra=False):
s = str(valore)
return s.rjust(larghezza) if allinea_a_destra else s.ljust(larghezza)


def colore_testo(c):
pass


def sme_in_vettore(n, a_vett):
return n in a_vett[1:]


def verifica_filtro(dec, cad, s_dec, s_cad):
b_dec_trovata = False
b_cad_trovata = False

s_dec = (s_dec or "").strip()
s_cad = (s_cad or "").strip()

if s_dec:
for x in s_dec.split(","):
x = x.strip()
if x and int(x) == dec:
b_dec_trovata = True
break

if s_cad:
for x in s_cad.split(","):
x = x.strip()
if x and int(x) == cad:
b_cad_trovata = True
break

return b_dec_trovata or b_cad_trovata


def ordina_desc_per_rit(a_tmp_num, a_tmp_rit, k):
for a in range(1, k):
for b in range(1, k - a + 1):
if a_tmp_rit < a_tmp_rit[b + 1]:
a_tmp_rit, a_tmp_rit[b + 1] = a_tmp_rit[b + 1], a_tmp_rit
a_tmp_num, a_tmp_num[b + 1] = a_tmp_num[b + 1], a_tmp_num


def esegui_analisi(s_decine_scelte, s_cadenze_scelte):
global SCRIPT_INTERROTTO

# 1. Generazione automatica della massa dei numeri
a_numeri = [0] # indice 0 non usato, come nel VB
for id_num in range(1, 91):
dec = id_num // 10
cad = id_num % 10

if verifica_filtro(dec, cad, s_decine_scelte, s_cadenze_scelte):
a_numeri.append(id_num)

k = len(a_numeri) - 1

a_tmp_num = [0] * (k + 1)
a_tmp_rit = [0] * (k + 1)

if k == 0:
print("Attenzione: nessun numero soddisfa i criteri inseriti. Controlla le configurazioni.")
return

# Inizializzazioni
a_conta_q = [0] * 12
a_conta_c = [0] * 12
a_freq_num = [0] * 91

# a_ultima_uscita[ruota][numero]
a_ultima_uscita = [[0] * 91 for _ in range(12)]
a_ritardo = [[0] * 91 for _ in range(12)]

# --- VISUALIZZAZIONE MASSA DEI NUMERI A MONTE ---
colore_testo(2)
print("=" * 80)
print(f" MASSA NUMERICA DI ANALISI (Totale Numeri: {k})")
print(f" Decine esaminate: [{s_decine_scelte}] | Cadenze esaminate: [{s_cadenze_scelte}]")
print("=" * 80)

s_elenco = ""
for i in range(1, k + 1):
s_elenco += format2(a_numeri) + " "
if i % 24 == 0:
print(s_elenco)
s_elenco = ""

if s_elenco:
print(s_elenco)

print("-" * 80)
colore_testo(1)

print(" STORICO EVENTI DI QUATERNA E CINQUINA")
print("-" * 80)
print(" N. | Data | Ruota | Esito | Numeri Sortiti")
print("-" * 80)

c_tot_eventi = 0

# 2. Scansione dell'archivio storico
for es in range(3549, ESTRAZIONI_ARCHIVIO + 1):
if SCRIPT_INTERROTTO:
colore_testo(2)
print("-" * 80)
print("--> Elaborazione interrotta dall'utente.")
return

# Nel VB il ciclo era: For r = 1 To 12, salta 11, mappa 12 -> 11.
# Qui è equivalente a considerare direttamente le ruote 1..11.
for r_vera in range(1, 12):
n_trovati = 0
s_numeri = ""
n_tmp_count = 0
a_trovati_temp = [0] * 6 # massimo 5 numeri

for p in range(1, 6):
n_estratto = estratto(es, r_vera, p)

if sme_in_vettore(n_estratto, a_numeri):
n_trovati += 1
s_numeri += format2(n_estratto) + " "
n_tmp_count += 1
a_trovati_temp[n_tmp_count] = n_estratto

if n_trovati >= 4:
c_tot_eventi += 1

if n_trovati == 4:
s_esito = "QUATERNA"
a_conta_q[r_vera] += 1
else:
s_esito = "CINQUINA"
a_conta_c[r_vera] += 1

for jj in range(1, n_tmp_count + 1):
num = a_trovati_temp[jj]
a_freq_num[num] += 1
a_ultima_uscita[r_vera][num] = es

print(
format_space(c_tot_eventi, 4, True) + " | " +
data_estrazione(es) + " | " +
format_space(nome_ruota(r_vera), 10, False) + " | " +
format_space(s_esito, 8, False) + " | " +
s_numeri
)

# --- RIEPILOGO PER RUOTA ---
colore_testo(2)
print("-" * 80)
print(" RIEPILOGO FREQUENZE PER RUOTA (Quaterne / Cinquine)")
print("-" * 80)

for i in range(1, 12):
print(
format_space(nome_ruota(i), 10, False) +
" | Quaterne: " + str(a_conta_q) +
" | Cinquine: " + str(a_conta_c) +
" | Totale: " + str(a_conta_q + a_conta_c)
)

# --- RIEPILOGO FREQUENZA SINGOLI NUMERI ---
print("-" * 80)
print(" FREQUENZA DEI NUMERI DELLA MASSA ALL'INTERNO DEGLI EVENTI Q/C (ordinati)")
print("-" * 80)

for i in range(1, k + 1):
a_tmp_num = a_numeri
a_tmp_rit = a_freq_num[a_numeri]

ordina_desc_per_rit(a_tmp_num, a_tmp_rit, k)

for i in range(1, k + 1):
print(
format_space(format2(a_tmp_num), 4, False) +
" | Presenze in eventi Q/C: " + str(a_tmp_rit)
)

print("-" * 80)
print(f"Scansione completata. Totale eventi trovati: {c_tot_eventi}")
colore_testo(0)

# --- METODO PREVISIVO: RITARDO SULLA MASSA, PER RUOTA ---
colore_testo(2)
print("-" * 80)
print(" METODO PREVISIVO (Ritardo sulla massa numerica, per ruota)")
print(" Ritardo = estrazioni trascorse dall'ultima comparsa in un evento Q/C su quella ruota")
print("-" * 80)
colore_testo(1)

for n_ruota_idx in range(1, 12):
for i in range(1, k + 1):
n_num_idx = a_numeri

if a_ultima_uscita[n_ruota_idx][n_num_idx] == 0:
a_ritardo[n_ruota_idx][n_num_idx] = ESTRAZIONI_ARCHIVIO - 3549 + 1
else:
a_ritardo[n_ruota_idx][n_num_idx] = (
ESTRAZIONI_ARCHIVIO - a_ultima_uscita[n_ruota_idx][n_num_idx]
)

for i in range(1, k + 1):
a_tmp_num = a_numeri
a_tmp_rit = a_ritardo[n_ruota_idx][a_numeri]

ordina_desc_per_rit(a_tmp_num, a_tmp_rit, k)

s_riga = " "
n_limit = k if k < 10 else 10

for i in range(1, n_limit + 1):
s_riga += format2(a_tmp_num) + "(" + str(a_tmp_rit) + ") "

print(
format_space(nome_ruota(n_ruota_idx), 10, False) +
" | Top 10 ritardatari (dalla massa): " + s_riga
)

print("-" * 80)
print("NB: il ritardo è calcolato SOLO sulle uscite in eventi di quaterna/cinquina.")
colore_testo(0)


if __name__ == "__main__":
# Esempio: modificare le stringhe con le decine/cadenze desiderate
esegui_analisi("", "")
 

Ultima estrazione Lotto

  • Estrazione del lotto
    venerdì 30 ottobre 2026
    Bari
    58
    79
    20
    27
    07
    Cagliari
    64
    45
    51
    54
    62
    Firenze
    84
    69
    21
    54
    78
    Genova
    70
    24
    76
    56
    73
    Milano
    32
    36
    19
    33
    72
    Napoli
    01
    38
    67
    70
    36
    Palermo
    78
    04
    72
    84
    74
    Roma
    58
    70
    85
    21
    34
    Torino
    49
    82
    36
    69
    84
    Venezia
    21
    86
    70
    33
    63
    Nazionale
    06
    24
    10
    28
    63
    Estrazione Simbolotto
    37
    35
    11
    36
    06

Ultimi Messaggi

Indietro
Alto