Novità

Intelligenza artificiale e lotto 🤖🎱📈📉🎯

Esito a colpo... da ultimissimo test del quale avevo condiviso solo il 54 purtroppo... 😌

IMG_20250128_212457_compress37.jpg

Ambo su ruota unica BA 49-52 🎯🎯

IMG_20250128_214109_compress32.jpg

Per cercare di beccare la coppia secca... per eventuali casi analoghi futuri... mi appunto e condivido che almeno in questo caso... i due elementi uscenti sarebbero stati nel guc3 di quelli con i primi tre Idc (indice di convenienza IndConv =(freq/EstrazioneFin-EstrazioneIni) * rit) max unici analizzando x s1 in c1 su ba dal 1871. La ruota target della search, in questo caso *, era solo BA. Le altre della bolletta erano per max copertura di test. * La search e' direzionabile verso qualsiasi ruota. I tre elementi contenenti i due punti a colpo avevano anche ra sincrono e ra max rispetto gli altri due della c5 oltre che le prime tre fq min uniche.



49 - .1. - Estratto - 18 - 126 - 0 - 589 - tp 715 - IndConv 1.00151143019082
RA |18| FQ |589|
36 - .1. - Estratto - 18 - 137 - 0 - 564 - tp 701 - IndConv 0.95900245607406
RA |18| FQ |564|
52 - .1. - Estratto - 18 - 129 - 0 - 546 - tp 675 - IndConv 0.928395994709994
RA |18| FQ |546|
54 - .1. - Estratto - 6 - 100 - 0 - 600 - tp 700 - IndConv 0.340071792934064
RA |6| FQ |600|
60 - .1. - Estratto - 1 - 110 - 0 - 633 - tp 743 - IndConv 5.97959569242396E-02
RA |1| FQ |633|
 
Ultima modifica:
lotto_tom 75 potresti fare una ricerca sulla ruota di NA ? GRAZIE
operai-a-7-bit.jpg

estrazioni-NA.txt
=== Risultati Finali ===
b1.txt: 9 (binario: 0001001 = 9)
b2.txt: 10 (binario: 0001010 = 10)
b3.txt: 11 (binario: 0001011 = 11)
b4.txt: 22 (binario: 0010110 = 22)
b5.txt: 48 (binario: 0110000 = 48)
=====================
dopo la correzione "bit" : NAPOLI diventa : (9)-10-(11)-22-(48) + 41-15
------------------------------------

nb: alcune risultanze di bit sono al 50% gestendo la lunghezza pattern = 18. DeepSeek uno di noi.. 😅. In sostanza la squadra AI si incrementa di un forte player: Claude+ChatGPT+DeepSeek+Mistral+Gemini+GoogleNotebookLM+Cursor.

Nessuna Certezza Solo Poca Probabilità
 
Ultima modifica:
Esito a colpo... da ultimissimo test del quale avevo condiviso solo il 54 purtroppo... 😌

Vedi l'allegato 2296792

Ambo su ruota unica BA 49-52 🎯🎯

Vedi l'allegato 2296793

Per cercare di beccare la coppia secca... per eventuali casi analoghi futuri... mi appunto e condivido che almeno in questo caso... i due elementi uscenti sarebbero stati nel guc3 di quelli con i primi tre Idc (indice di convenienza IndConv =(freq/EstrazioneFin-EstrazioneIni) * rit) max unici analizzando x s1 in c1 su ba dal 1871. La ruota target della search, in questo caso *, era solo BA. Le altre della bolletta erano per max copertura di test. * La search e' direzionabile verso qualsiasi ruota. I tre elementi contenenti i due punti a colpo avevano anche ra sincrono e ra max rispetto gli altri due della c5 oltre che le prime tre fq min uniche.



49 - .1. - Estratto - 18 - 126 - 0 - 589 - tp 715 - IndConv 1.00151143019082
RA |18| FQ |589|
36 - .1. - Estratto - 18 - 137 - 0 - 564 - tp 701 - IndConv 0.95900245607406
RA |18| FQ |564|
52 - .1. - Estratto - 18 - 129 - 0 - 546 - tp 675 - IndConv 0.928395994709994
RA |18| FQ |546|
54 - .1. - Estratto - 6 - 100 - 0 - 600 - tp 700 - IndConv 0.340071792934064
RA |6| FQ |600|
60 - .1. - Estratto - 1 - 110 - 0 - 633 - tp 743 - IndConv 5.97959569242396E-02
RA |1| FQ |633|

Al 2° colpo cascato (e preso) ambo in c5 su NZ (la metto solo x curiosità visto che NZ e TT erano solo a recupero...)

s2inc5alsecondocolpo.jpg
 
penso e mi ripeto sempre: le cose piu piccole e semplici fanno la differenza ,in questo caso una gui semplicissima porta e porterà risultati eccellenti ..
sempre la mano del padrone a far la differenza è chiaro.
 
Nonostante sia da ottimizzare e correggere su su molti punti condivido il code dell'ultima versione (script-analisi-0-1-versioneforsefinale-38.py) x i + smanettoni tra di voi :) In questa versione è stato corretto l'ordinamento di ricerca (dal basso verso l'alto e l'implementazione di un abbozzo di automazione e di ricerca della condizione teoricamente + ottimale). Anche l'interfaccia presenta molti + campi e bottoni rispetto alla soprastante.

Codice:
import os
import time
from datetime import datetime
from tkinter import Tk, filedialog, Checkbutton, IntVar, Button, Label, Entry, Frame
from collections import Counter, defaultdict
import winsound

class Logger:
    def __init__(self, cartella_output):
        self.start_time = time.time()
        self.log_filename = os.path.join(cartella_output,
                                         f"log_elaborazione_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")

    def log(self, messaggio):
        with open(self.log_filename, 'a', encoding='utf-8') as f:
            timestamp = datetime.now().strftime('%H:%M:%S')
            f.write(f"[{timestamp}] {messaggio}\n")
        print(messaggio)

    def tempo_totale(self):
        tempo_totale = time.time() - self.start_time
        return f"{tempo_totale:.2f} secondi"

class ReportCasiOttimali:
    def __init__(self, cartella_output):
        self.report_path = os.path.join(cartella_output, "reportcasiottimali.txt")
        with open(self.report_path, 'w', encoding='utf-8') as f:
            f.write("=== Report Casi Ottimali ===\n\n")
        self.casi_trovati = False

    def aggiungi_caso(self, file_estrazioni, file_b, posizione, prob_0, prob_1):
        self.casi_trovati = True
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"File estrazioni: {file_estrazioni}\n")
            f.write(f"File binario: {file_b}\n")
            f.write(f"Probabilità '0': {prob_0:.2%}\n")
            f.write(f"Probabilità '1': {prob_1:.2%}\n")
            f.write("-" * 50 + "\n")

    def finalizza_report(self):
        if not self.casi_trovati:
            with open(self.report_path, 'a', encoding='utf-8') as f:
                f.write("Nessun caso ottimale trovato.\n")

class ReportRuote:
    def __init__(self, cartella_output, nome_file):
        self.report_path = os.path.join(cartella_output, nome_file)
        if not os.path.exists(self.report_path):
            with open(self.report_path, 'w', encoding='utf-8') as f:
                f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

    def aggiungi_ruota(self, ruota):
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"{ruota}\n")

class CarrelloPredizioni:
    def __init__(self):
        self.carrelli = defaultdict(lambda: ['_'] * 7)
        self.ruota_corrente = None

    def set_ruota(self, nome_file_input):
        if nome_file_input.startswith('estrazioni-'):
            self.ruota_corrente = nome_file_input.split('-')[1].split('.')[0]

    def aggiungi_predizione(self, file_origine, posizione, valore):
        file_base = os.path.basename(file_origine)
        parti = file_base.split('-')
        numero_file = ''.join(filter(str.isdigit, parti[0]))
        chiave = f"b{numero_file}"
        try:
            posizione = int(parti[1].split('.')[0])
            if 0 <= posizione < 7:
                self.carrelli[chiave][posizione] = valore
        except (ValueError, IndexError) as e:
            print(f"Errore: {e}")

    def mostra_risultati(self, logger, cartella_output):
        logger.log("\n=== Risultati Finali ===")
        script_dir = os.path.dirname(os.path.abspath(__file__))
        report_path = os.path.join(script_dir, "previsionielaborate.txt")
        numeri_decimali = []
        for chiave in sorted(self.carrelli.keys()):
            sequenza_binaria = ''.join(self.carrelli[chiave])
            numero_decimale = str(int(sequenza_binaria, 2))
            numeri_decimali.append(numero_decimale)
            logger.log(f"{chiave}.txt: {numero_decimale} (binario: {sequenza_binaria} = {int(sequenza_binaria, 2)})")
        with open(report_path, 'a', encoding='utf-8') as report:
            if self.ruota_corrente and numeri_decimali:
                report.write(f"{self.ruota_corrente} {'-'.join(numeri_decimali)}\n")
        logger.log("=====================")
        logger.log(f"Report salvato in: {report_path}")

def decimale_a_binario(decimale):
    return '.'.join(format(int(decimale), '07b'))

def converte_file_decimale(file_decimale, cartella_output, logger):
    colonne = []
    with open(file_decimale, 'r') as file:
        for linea in file:
            valori = linea.strip().split('.')
            for i, valore in enumerate(valori):
                if len(colonne) <= i:
                    colonne.append([])
                colonne[i].append(decimale_a_binario(valore))
    file_binari = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{i + 1}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_binari.append(nome_file)
        logger.log(f"File binario generato: {nome_file}")
    return file_binari

def split_file_binario(file_binario, cartella_output, logger):
    base_name = os.path.basename(file_binario)
    numero_file = ''.join(filter(str.isdigit, base_name.split('.')[0]))
    with open(file_binario, 'r') as file:
        righe = [line.strip().split('.') for line in file]
        colonne = list(zip(*righe))
    file_splittati = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{numero_file}-{i}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_splittati.append(nome_file)
        logger.log(f"File splittato generato: {nome_file}")
    return file_splittati

def carica_dati(file_path):
    with open(file_path, 'r') as file:
        # Legge i dati e INVERTE l'ordine per avere i più vecchi in alto durante l'analisi
        dati = [bit for line in file for bit in line.strip().split('.')]
        return dati[::-1]  # <-- Modifica chiave qui

def analizza_file(file_binario, lunghezza_sequenza, carrello, logger, report_ottimali, file_estrazioni,
                  soglia_minima, analisi_automatica):
    posizione = int(os.path.basename(file_binario).split('-')[1].split('.')[0])
    dati = carica_dati(file_binario)  # Dati ora sono invertiti: [vecchio, ..., recente]

    logger.log(f"\nAnalisi pattern per {file_binario}")
    logger.log(f"Posizione bit analizzata: bit{posizione}.txt")
    logger.log(f"Lunghezza sequenza pattern: {lunghezza_sequenza}")

    # Controllo per assicurarsi che la lunghezza del pattern sia valida
    if lunghezza_sequenza <= 0:
        logger.log(f"Lunghezza sequenza pattern non valida: {lunghezza_sequenza}")
        return False

    # Pattern iniziale preso dalla FINE dei dati invertiti (corrisponde ai più RECENTI nel file originale)
    initial_pattern = tuple(dati[-lunghezza_sequenza:])  # <-- Modifica qui

    preceding_bits = []

    # Analizza dal basso (vecchio) verso l'alto (recente) nei dati invertiti
    for i in range(len(dati) - lunghezza_sequenza):
        current_window = tuple(dati[i:i + lunghezza_sequenza])
        if current_window == initial_pattern and i + lunghezza_sequenza < len(dati):
            # Il bit successivo è quello DOPO la finestra, verso l'alto (più recente)
            preceding_bit = dati[i + lunghezza_sequenza]
            preceding_bits.append(preceding_bit)

    count_0 = preceding_bits.count('0')
    count_1 = preceding_bits.count('1')
    total = len(preceding_bits)

    if total == 0:
        prob_0, prob_1 = 0.5, 0.5
    else:
        prob_0 = count_0 / total
        prob_1 = count_1 / total

    occ = {'0': count_0, '1': count_1}
    TOLLERANZA = 0.0001
    is_optimal = any(abs(prob - 1.0) < TOLLERANZA for prob in [prob_0, prob_1])

    # Controllo per identificare i casi con esattamente un bit inferiore alla soglia minima
    if analisi_automatica:
        bit_inferiori = [bit for bit in preceding_bits if (bit == '0' and prob_0 < soglia_minima / 100) or (bit == '1' and prob_1 < soglia_minima / 100)]
        if len(bit_inferiori) == 1:
            file_b = os.path.basename(file_binario).split('-')[0] + ".txt"
            report_ottimali.aggiungi_caso(
                os.path.basename(file_estrazioni),
                file_b,
                posizione,
                prob_0,
                prob_1
            )
            return True

    valore_predetto = '0' if prob_0 > prob_1 else '1'
    prob_valore = prob_0 if valore_predetto == '0' else prob_1

    logger.log(f"Sequenza iniziale: {''.join(initial_pattern)}")
    logger.log(f"Occorrenze trovate del pattern: {total}")
    logger.log(f"Probabilità '0': {prob_0:.2%} (occorrenze: {count_0})")
    logger.log(f"Probabilità '1': {prob_1:.2%} (occorrenze: {count_1})")
    logger.log(f"Valore predetto: {valore_predetto} (probabilità: {prob_valore:.2%})")

    carrello.aggiungi_predizione(file_binario, posizione, valore_predetto)

    # Aggiunto controllo per fermarsi se tutte le probabilità sono maggiori o uguali alla soglia
    if prob_0 >= soglia_minima / 100 and prob_1 >= soglia_minima / 100:
        return True

    return is_optimal

def processo_automatico(file_input, lunghezza_sequenza, righe_da_analizzare=10000, soglia_minima=100, analisi_automatica=False):
    cartella_output = os.path.dirname(os.path.abspath(file_input))
    nome_file = os.path.basename(file_input)
    logger = Logger(cartella_output)
    report_ottimali = ReportCasiOttimali(cartella_output)
    report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
    report_ruote_non_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTENONOTTIMALI.txt")
    logger.log(f"Inizio elaborazione")
    logger.log(f"File input: {nome_file}")
    logger.log(f"Cartella output: {cartella_output}")
    logger.log(f"Lunghezza sequenza: {lunghezza_sequenza}")
    logger.log(f"Righe da analizzare: {righe_da_analizzare}")
    logger.log(f"Soglia minima: {soglia_minima}%")
    logger.log("\nConversione file decimale in binari...")

    with open(file_input, 'r') as file:
        lines = []
        for i, line in enumerate(file):
            if i < righe_da_analizzare:
                lines.append(line)
            else:
                break

    temp_file = os.path.join(cartella_output, "temp_estrazioni.txt")
    with open(temp_file, 'w') as file:
        file.writelines(lines)

    file_binari = converte_file_decimale(temp_file, cartella_output, logger)
    carrello = CarrelloPredizioni()
    carrello.set_ruota(nome_file)
    is_ruota_ottimale = True

    for file_binario in file_binari:
        logger.log(f"\nElaborazione {os.path.basename(file_binario)}...")
        file_splittati = split_file_binario(file_binario, cartella_output, logger)
        for file_splittato in file_splittati:
            if not analizza_file(file_splittato, lunghezza_sequenza, carrello, logger, report_ottimali, nome_file, soglia_minima, analisi_automatica):
                is_ruota_ottimale = False

    if is_ruota_ottimale:
        report_ruote_ottimali.aggiungi_ruota(carrello.ruota_corrente)
    else:
        report_ruote_non_ottimali.aggiungi_ruota(carrello.ruota_corrente)

    carrello.mostra_risultati(logger, cartella_output)
    report_ottimali.finalizza_report()
    tempo_totale = logger.tempo_totale()
    logger.log(f"\nTempo totale di elaborazione: {tempo_totale}")
    logger.log(f"Report casi ottimali salvato in: {report_ottimali.report_path}")
    logger.log(f"Report ruote ottimali salvato in: {report_ruote_ottimali.report_path}")
    logger.log(f"Report ruote non ottimali salvato in: {report_ruote_non_ottimali.report_path}")

    os.remove(temp_file)

    return report_ottimali.casi_trovati

def ottieni_percorso_file_estrazioni(ruota):
    return os.path.join(ruota, f"estrazioni-{ruota}.txt")

def inizializza_report_ruote():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    for nome_file in ["RUOTEOTTIMALI.txt", "RUOTENONOTTIMALI.txt"]:
        report_path = os.path.join(script_dir, nome_file)
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

def main():
    root = Tk()
    root.title("Seleziona Ruote")

    pattern_frame = Frame(root)
    pattern_frame.pack(pady=10)
    Label(pattern_frame, text="Lunghezza pattern:").pack(side='left')
    pattern_length = Entry(pattern_frame, width=5)
    pattern_length.insert(0, "18")
    pattern_length.pack(side='left', padx=5)

    righe_frame = Frame(root)
    righe_frame.pack(pady=10)
    Label(righe_frame, text="Prime righe da analizzare:").pack(side='left')
    righe_da_analizzare = Entry(righe_frame, width=5)
    righe_da_analizzare.insert(0, "10000")
    righe_da_analizzare.pack(side='left', padx=5)

    soglia_frame = Frame(root)
    soglia_frame.pack(pady=10)
    Label(soglia_frame, text="Soglia minima di probabilità (%):").pack(side='left')
    soglia_minima = Entry(soglia_frame, width=5)
    soglia_minima.insert(0, "100")
    soglia_minima.pack(side='left', padx=5)

    analisi_automatica_var = IntVar()
    Checkbutton(root, text="Analisi e selezione automatica", variable=analisi_automatica_var).pack(pady=5)

    Label(root, text="Seleziona le ruote da analizzare:").pack()

    ruote = ["BA", "CA", "FI", "GE", "MI", "NA", "PA", "RO", "TO", "VE", "NZ"]
    ruote_vars = {ruota: IntVar() for ruota in ruote}

    checkbuttons_frame = Frame(root)
    checkbuttons_frame.pack(pady=5)

    for ruota in ruote:
        Checkbutton(checkbuttons_frame, text=ruota, variable=ruote_vars[ruota]).pack(anchor='w')

    buttons_frame = Frame(root)
    buttons_frame.pack(pady=10)

    def seleziona_tutto():
        for var in ruote_vars.values():
            var.set(1)

    def deseleziona_tutto():
        for var in ruote_vars.values():
            var.set(0)

    def analizza():
        try:
            lunghezza_seq = int(pattern_length.get())
            righe = int(righe_da_analizzare.get())
            soglia = float(soglia_minima.get())
            analisi_automatica = analisi_automatica_var.get()
            ruote_selezionate = [ruota for ruota, var in ruote_vars.items() if var.get()]

            inizializza_report_ruote()

            if analisi_automatica:
                lunghezza_seq_iniziale = lunghezza_seq
                while True:
                    casi_trovati = False
                    for ruota in ruote_selezionate:
                        file_input = ottieni_percorso_file_estrazioni(ruota)
                        if os.path.exists(file_input):
                            logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                            logger.log(f"Analizzando ruota: {ruota}")
                            logger.log(f"File input: {file_input}")
                            logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                            logger.log(f"Righe da analizzare: {righe}")
                            logger.log(f"Soglia minima: {soglia}%")
                            if processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica):
                                casi_trovati = True
                                logger.log(f"Ruota ottimale trovata: {ruota}")
                                report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
                                report_ruote_ottimali.aggiungi_ruota(f"RUOTA OTTIMALE: {ruota}")
                                winsound.Beep(1000, 2000)  # Emette un bip sonoro a 1000 Hz per 2 secondi
                                break
                    if casi_trovati:
                        break
                    lunghezza_seq += 1
                    logger.log(f"Aumentando la lunghezza del pattern a {lunghezza_seq}")
            else:
                for ruota in ruote_selezionate:
                    file_input = ottieni_percorso_file_estrazioni(ruota)
                    if os.path.exists(file_input):
                        logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                        logger.log(f"Analizzando ruota: {ruota}")
                        logger.log(f"File input: {file_input}")
                        logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                        logger.log(f"Righe da analizzare: {righe}")
                        logger.log(f"Soglia minima: {soglia}%")
                        processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica)
                    else:
                        print(f"File di estrazioni per la ruota {ruota} non trovato.")
        except ValueError:
            print("Errore: inserire valori numerici validi.")

    Button(buttons_frame, text="Seleziona Tutto", command=seleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Deseleziona Tutto", command=deseleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Analizza", command=analizza).pack(side='left', padx=5)

    root.mainloop()

if __name__ == "__main__":
    main()

Per testarlo, e magari contribuire alla sua ottimizzazione e/o correzione, è necessario creare 11 cartelle : BA , CA , FI ecc... fino a NZ con dentro i rispettivi file estrazioni-BA.txt ecc... contenenti ognuno le estrazioni della rispettiva ruota con la prima estrazione in alto e l'ultima in basso in formato con i 5 estratti a doppia cifra (i numeri da 1 a 9 con lo 0 davanti) intervallata da carattere punto (es. 01.88.77.32.05). AI utilizzate per adesso per questo script py: Claude Sonnet 3.5, DeepSeek, ChatGpt e Mistral. Selezionando "Analizza e seleziona automaticamente" lo script continuerà la ricerca ad libitum aumentando la lunghezza del pattern iniziale di una unità ad ogni nuovo ciclo.. Per adesso lo script si potrà interrompere solo bruscamente.. con ctrl + s (pausa) e ctrl + q (prosegui) o con ctrl + c (chiudi) o chiudendo direttamente la finestra dos. Per ovviare a questo comunque basta comunque implementarvi un bottone per chiuderlo in modo + dolce... o non selezionare quell'opzione di analisi automatica... :)

breve schema e spiegazione dell'idea di base che ho avuto e che mi ha spinto a voler cercare di realizzare questo script :

la sequenza di estratti di ogni estrazione e per ogni ruota viene convertita in rispettivi numeri binari a 7 bit i quali vengono a loro volta scomposti nelle 7 colonne di bit (da bit0 a bit6). Queste 7 colonne vengono analizzate una ad una a partire dal basso verso l'alto dopo che è stato costruito un pattern spia di ricerca prelevando i primi elementi di ciascuna colonna a partire dall'alto. Questa operazione si può fare sia staticamente scegliendo una lunghezza fissa sia dinamicamente lasciando appunto allo script di aumentare ad ogni ciclo la lunghezza del pattern di partenza... Lo script dovrà quindi annotarsi tutte le quantità di 0 e di 1 che incontrerà per ciascuna colonna di bit dopo la sequenza del pattern di ricerca e in base alla loro presenza maggiore e quindi relativa probabilità di apparizione ipotizzare quale ci sarà dopo l'ultimo bit in alto della rispettiva colonna analizzata... Per far questo è possibile scegliere statisticamente una % minima di presenza per far si che il bit che la raggiunge o supera sia considerato + probabile dell'altro.



schema.jpg
 
Ultima modifica:

Ultima estrazione Lotto

  • Estrazione del lotto
    venerdì 31 gennaio 2025
    Bari
    49
    28
    64
    42
    46
    Cagliari
    53
    76
    89
    26
    13
    Firenze
    38
    51
    15
    50
    56
    Genova
    87
    09
    35
    30
    04
    Milano
    53
    25
    23
    09
    37
    Napoli
    01
    65
    38
    06
    15
    Palermo
    05
    07
    10
    26
    58
    Roma
    32
    31
    09
    46
    80
    Torino
    68
    20
    44
    51
    11
    Venezia
    90
    24
    62
    54
    61
    Nazionale
    20
    79
    07
    45
    60
    Estrazione Simbolotto
    Bari
    45
    37
    01
    41
    17
Indietro
Alto