Em `Contagens (XXX)` quero que adicione do lado dele: `- Dragon (XX) - Tiger (XX)`

O XX seria o total para Dragon e Tiger da sequencia atual independente se é maior ou menor

[Mande o código completo e atualizado]

```python
import csv
import tkinter as tk
from tkinter import ttk

# Imports da API
import requests
import json
import time
import websocket
import threading
import logging
from requests.exceptions import RequestException
from typing import Dict, Optional
import queue

# Configuração simplificada de logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')

opcoes = [
    "Dragon-Maior", "Dragon-Menor", "Tie-Menor",
    "Tiger-Maior", "Tiger-Menor", "SuitedTie-Menor"
]

# Função para obter o EVOSESSIONID
def obter_evosessionid() -> Optional[str]:
    url_post = "https://blaze.com/api/games/dragon-tiger-evolution/play"
    headers = {
        "Host": "blaze.com",
        "Content-Type": "application/json;charset=UTF-8",
        "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6NTAwNTQyMDIsImJsb2NrcyI6W10sInV1aWQiOiJjYWJlNzBiMC1hZDcxLTRiZGEtOGNmYy00OGIxYjFkYmQ3NGIiLCJpYXQiOjE3Mjc4NzE0MjMsImV4cCI6MTczMzA1NTQyM30.XA5LzxR0-ILTf2ODiLP-G_2PjEVmEjOs50TSdeOJWj8",  # Substitua pelo seu token válido
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
        "Accept": "application/json, text/plain, */*",
        "Origin": "https://blaze.com",
        "Referer": "https://blaze.com/pt/games/dragon-tiger-evolution",
        "Accept-Language": "en-US,en;q=0.9,pt-BR;q=0.8,pt;q=0.7",
        "x-client-language": "pt",
        "x-client-version": "v2.2181.0",
    }
    payload = {"selected_currency_type": "BRL"}

    try:
        with requests.Session() as session:
            resposta = session.post(url_post, headers=headers, json=payload, timeout=30)
            resposta.raise_for_status()

            dados = resposta.json()
            url_ws = dados.get("url")

            if url_ws:
                time.sleep(1)
                headers_get = {
                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9",
                    "Accept-Language": "en-US,en;q=0.9,pt-BR;q=0.8,pt;q=0.7",
                    "Referer": "https://blaze.com/",
                }
                resposta_get = session.get(url_ws, headers=headers_get, allow_redirects=True, timeout=30)
                resposta_get.raise_for_status()

                return session.cookies.get('EVOSESSIONID')
    except RequestException as e:
        logging.error(f"Erro ao obter EVOSESSIONID: {e}")
    return None

# Classe para gerenciar o WebSocket
class DragonTigerWebSocket:
    def __init__(self, evosessionid: str, result_queue: queue.Queue):
        self.evosessionid = evosessionid
        self.apostas: Dict[str, int] = {"Dragon": 0, "Tiger": 0}
        self.url_ws = (
            f"wss://a8r.evo-games.com/public/dragontiger/player/game/DragonTiger00001/socket"
            f"?messageFormat=json&tableConfig=qfgyebpdhvchztoh&EVOSESSIONID={evosessionid}"
            f"&instance=ceurmi-pgkuwspw45weqgsa-qfgyebpdhvchztoh&client_version=6.20240927.72917.44963-240dc36920"
        )
        self.ws: Optional[websocket.WebSocketApp] = None
        self.thread: Optional[threading.Thread] = None
        self.result_queue = result_queue

    def on_message(self, ws: websocket.WebSocketApp, message: str) -> None:
        try:
            data = json.loads(message)
            if data.get('type') == 'dragontiger.bettingStats':
                self.apostas = {
                    "Dragon": data['args']['stats']['Dragon']['amount'],
                    "Tiger": data['args']['stats']['Tiger']['amount']
                }
            elif data.get('type') == 'dragontiger.resolved':
                vencedor = data['args']['result']['winner']
                comparacao = "Maior" if (
                    (vencedor == "Dragon" and self.apostas["Dragon"] > self.apostas["Tiger"]) or
                    (vencedor == "Tiger" and self.apostas["Tiger"] > self.apostas["Dragon"])
                ) else "Menor"
                resultado = f"{vencedor}-{comparacao}"
                logging.info(f"Resultado capturado: {resultado}")
                self.result_queue.put(resultado)
        except json.JSONDecodeError as e:
            logging.error(f"Erro ao decodificar JSON: {e}")
        except KeyError as e:
            logging.error(f"Erro ao acessar chave no dicionário: {e}")
        except Exception as e:
            logging.error(f"Erro ao processar a mensagem: {e}")

    def on_error(self, ws: websocket.WebSocketApp, error: Exception) -> None:
        logging.error(f"Erro na conexão WebSocket: {error}")

    def on_close(self, ws: websocket.WebSocketApp, close_status_code: Optional[int], close_msg: Optional[str]) -> None:
        logging.warning(f"Conexão WebSocket fechada: {close_status_code} - {close_msg}")

    def on_open(self, ws: websocket.WebSocketApp) -> None:
        logging.info("Conexão WebSocket estabelecida")

    def conectar(self) -> None:
        try:
            self.ws = websocket.WebSocketApp(
                self.url_ws,
                on_open=self.on_open,
                on_message=self.on_message,
                on_error=self.on_error,
                on_close=self.on_close
            )

            self.thread = threading.Thread(target=self.ws.run_forever, kwargs={'ping_interval': 60, 'ping_timeout': 10})
            self.thread.daemon = True
            self.thread.start()
            logging.info("Thread WebSocket iniciada")
        except Exception as e:
            logging.error(f"Erro ao conectar WebSocket: {e}")

    def parar(self) -> None:
        if self.ws:
            self.ws.close()
        if self.thread and self.thread.is_alive():
            self.thread.join()
        logging.info("WebSocket parado")

# Função para iniciar o WebSocket
def start_websocket():
    while True:
        logging.info("Obtendo EVOSESSIONID...")
        evosessionid = obter_evosessionid()

        if evosessionid:
            logging.info("EVOSESSIONID válido obtido. Estabelecendo conexão WebSocket...")
            dragon_tiger_ws = DragonTigerWebSocket(evosessionid, result_queue)
            dragon_tiger_ws.conectar()
            if dragon_tiger_ws.thread:
                dragon_tiger_ws.thread.join()
            logging.info("Conexão WebSocket encerrada. Reconectando...")
        else:
            logging.error("Não foi possível obter um EVOSESSIONID válido. Tentando novamente em 30 segundos...")
            time.sleep(30)

# Função para ler o CSV inicial
def ler_csv(nome_arquivo):
    try:
        with open(nome_arquivo, 'r', encoding='utf-8') as arquivo:
            leitor = csv.reader(arquivo)
            resultados = []
            for linha in leitor:
                if linha:
                    resultados.append(linha[0].strip())
            return resultados
    except FileNotFoundError:
        logging.warning(f"Arquivo {nome_arquivo} não encontrado. Iniciando com lista de resultados vazia.")
        return []

def contar_sequencia(resultados, sequencia):
    contador = 0
    i = 0
    while i <= len(resultados) - len(sequencia):
        if resultados[i:i+len(sequencia)] == sequencia:
            contador += 1
            i += len(sequencia)
        else:
            i += 1
    return contador

def contar_proxima_previsao(resultados, sequencia):
    contagem = {opcao: 0 for opcao in opcoes}
    i = 0
    while i <= len(resultados) - len(sequencia) - 1:
        if resultados[i:i+len(sequencia)] == sequencia:
            proxima = resultados[i+len(sequencia)]
            if proxima in contagem:
                contagem[proxima] += 1
            i += len(sequencia)
        else:
            i += 1
    return contagem

# Carrega os resultados iniciais do CSV
resultados = ler_csv('resultados_dragon_tiger.csv')

max_sequencia_len = 6
sequencia_atual = []

def atualizar_sequencia(opcao):
    if len(sequencia_atual) >= max_sequencia_len:
        sequencia_atual.pop(0)
    sequencia_atual.append(opcao)
    atualizar_display_sequencia()
    atualizar_contagens()

def atualizar_display_sequencia():
    for widget in frame_sequencia_itens.winfo_children():
        widget.destroy()

    sequencia_label.config(text=f"Sequência atual ({len(sequencia_atual)}):")

    canvas = tk.Canvas(frame_sequencia_itens, height=30)
    scrollbar = ttk.Scrollbar(frame_sequencia_itens, orient="horizontal", command=canvas.xview)
    scrollable_frame = ttk.Frame(canvas)

    canvas.configure(xscrollcommand=scrollbar.set)

    canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")

    for idx, opcao in enumerate(sequencia_atual):
        btn = ttk.Button(scrollable_frame, text=opcao, command=lambda idx=idx: remover_item_sequencia(idx))
        btn.pack(side="left", padx=2, pady=2)

    canvas.pack(side="top", fill="x", expand=True)
    scrollbar.pack(side="bottom", fill="x")

    scrollable_frame.update_idletasks()
    canvas.configure(scrollregion=canvas.bbox("all"))

def remover_item_sequencia(idx):
    del sequencia_atual[idx]
    atualizar_display_sequencia()
    atualizar_contagens()

def atualizar_contagens():
    if sequencia_atual:
        contagem_seq = contar_sequencia(resultados, sequencia_atual)
        frame_contagens.config(text=f"Contagens ({contagem_seq})")
        proxima_contagem = contar_proxima_previsao(resultados, sequencia_atual)
        for item in treeview.get_children():
            treeview.delete(item)
        itens_ordenados = sorted(proxima_contagem.items(), key=lambda x: x[1], reverse=True)
        for opcao, contagem in itens_ordenados:
            treeview.insert("", "end", values=(opcao, contagem))
    else:
        frame_contagens.config(text="Contagens (0)")
        for item in treeview.get_children():
            treeview.delete(item)

def limpar_sequencia():
    sequencia_atual.clear()
    atualizar_display_sequencia()
    atualizar_contagens()

def desfazer():
    if sequencia_atual:
        sequencia_atual.pop()
        atualizar_display_sequencia()
        atualizar_contagens()

# Cria a janela principal
janela = tk.Tk()
janela.title("Análise de Sequências Dragon Tiger")

# Configuração do tema escuro
def configurar_tema_escuro():
    style = ttk.Style()
    style.theme_use('clam')

    style.configure('.', background='#2E2E2E', foreground='white')
    style.configure('TLabel', background='#2E2E2E', foreground='white')
    style.configure('TButton', background='#4A4A4A', foreground='white')
    style.configure('TLabelframe', background='#2E2E2E', foreground='white')
    style.configure('TLabelframe.Label', background='#2E2E2E', foreground='white')
    style.configure('Treeview', background='#3E3E3E', foreground='white', fieldbackground='#3E3E3E')
    style.configure('Treeview.Heading', background='#4A4A4A', foreground='white')

    style.map('TButton', background=[('active', '#5A5A5A')])
    style.map('Treeview', background=[('selected', '#5A5A5A')], foreground=[('selected', 'white')])

configurar_tema_escuro()

janela.configure(bg='#2E2E2E')

style = ttk.Style()
style.configure("TButton", font=("Arial", 12))
style.configure("TLabel", font=("Arial", 12))
style.configure("Treeview", font=("Arial", 12))
style.configure("Treeview.Heading", font=("Arial", 12, "bold"))

# Configuração dos frames
frame_opcoes = ttk.LabelFrame(janela, text="Opções")
frame_opcoes.grid(row=0, column=0, padx=10, pady=(10,5), sticky="nsew")

frame_controles = ttk.LabelFrame(janela, text="Controles")
frame_controles.grid(row=0, column=1, padx=10, pady=(10,5), sticky="nsew")

frame_sequencia = ttk.LabelFrame(janela, text="Sequência")
frame_sequencia.grid(row=1, column=0, columnspan=2, padx=10, pady=5, sticky="nsew")

frame_contagens = ttk.LabelFrame(janela, text="Contagens (0)")
frame_contagens.grid(row=2, column=0, columnspan=2, padx=10, pady=(5,10), sticky="nsew")

# Configuração para expandir as colunas
janela.grid_rowconfigure(0, weight=0)
janela.grid_rowconfigure(1, weight=0)
janela.grid_rowconfigure(2, weight=1)
janela.grid_columnconfigure(0, weight=1)
janela.grid_columnconfigure(1, weight=1)

# Configurando o frame_opcoes
max_columns = 3
for i, opcao in enumerate(opcoes):
    row = i // max_columns
    column = i % max_columns
    btn = ttk.Button(frame_opcoes, text=opcao, command=lambda o=opcao: atualizar_sequencia(o))
    btn.grid(row=row, column=column, padx=5, pady=5, sticky="nsew")

for i in range(max_columns):
    frame_opcoes.grid_columnconfigure(i, weight=1)

# Configurando o frame_controles
ttk.Button(frame_controles, text="Limpar", command=limpar_sequencia).grid(row=0, column=0, padx=5, pady=5, sticky="nsew")
ttk.Button(frame_controles, text="Desfazer", command=desfazer).grid(row=0, column=1, padx=5, pady=5, sticky="nsew")

frame_controles.grid_columnconfigure(0, weight=1)
frame_controles.grid_columnconfigure(1, weight=1)

# Frame Sequência
sequencia_label = ttk.Label(frame_sequencia, text="Sequência atual (0):", font=("Arial", 12))
sequencia_label.pack(anchor="w", padx=5, pady=(5,0))
frame_sequencia_itens = ttk.Frame(frame_sequencia)
frame_sequencia_itens.pack(fill="x", padx=5, pady=5)

# Frame Contagens
contagem_str = tk.StringVar()

# Treeview
treeview = ttk.Treeview(frame_contagens, columns=("Opção", "Contagem"), show="headings", height=8)
treeview.heading("Opção", text="Opção")
treeview.heading("Contagem", text="Contagem")
treeview.column("Opção", width=150, anchor="center")
treeview.column("Contagem", width=150, anchor="center")
treeview.grid(row=0, column=0, sticky="nsew", padx=5, pady=(5,5))

# Scrollbar para o Treeview
scrollbar_treeview = ttk.Scrollbar(frame_contagens, orient="vertical", command=treeview.yview)
treeview.configure(yscrollcommand=scrollbar_treeview.set)
scrollbar_treeview.grid(row=0, column=1, sticky="ns", pady=(5,5))

# Configurações do frame_contagens
frame_contagens.grid_rowconfigure(0, weight=1)
frame_contagens.grid_columnconfigure(0, weight=1)

# Aplicando estilo aos frames
for frame in [frame_opcoes, frame_controles, frame_sequencia, frame_contagens]:
    frame.configure(style='TLabelframe')

janela.geometry("600x600")
janela.resizable(True, True)

# Cria a fila para os resultados
result_queue = queue.Queue()

# Função para verificar novos resultados
def check_new_results():
    try:
        while True:
            result = result_queue.get_nowait()
            # Processa o novo resultado
            resultados.append(result)
            logging.info(f"Novo resultado recebido: {result}")
            # Atualiza a sequência atual com o novo resultado
            atualizar_sequencia(result)
    except queue.Empty:
        pass
    # Agenda a próxima verificação
    janela.after(1000, check_new_results)

# Inicia o WebSocket em uma thread separada
websocket_thread = threading.Thread(target=start_websocket)
websocket_thread.daemon = True
websocket_thread.start()

# Inicia a verificação de novos resultados
check_new_results()

# Inicia a interface gráfica
janela.mainloop()
```