From 76bed0f3a8214b1e8a3b53c768d0124d02a9b1f6 Mon Sep 17 00:00:00 2001 From: Luciano Silva do Lago Date: Sun, 7 Jun 2026 20:57:37 -0300 Subject: [PATCH] feat: adiciona analise e Modelos 4, 5 e 6 exclusivos para a frota de aeronaves C-99A --- create_nb.py | 290 +++++++++++++++++++ modelos.ipynb | 770 +++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 990 insertions(+), 70 deletions(-) diff --git a/create_nb.py b/create_nb.py index d110799..ca1389d 100644 --- a/create_nb.py +++ b/create_nb.py @@ -568,6 +568,296 @@ print("== QUADRO DE HORÁRIOS DIÁRIOS (COM 40 MIN TAT) ==") print(tabulate(tabela_horarios3, headers=["Aeronave", "Origem", "Destino", "Tipo", "Partida", "Chegada", "Duração Voo"], tablefmt="github")) """)) + +# ========================================== +# SEÇÃO C-99 +# ========================================== +cells.append(nbf.v4.new_markdown_cell("""# Alocação de Frotas - Aeronaves C-99A +Agora replicaremos a mesma lógica e os mesmos modelos (1, 2 e 3) para a aeronave C-99A (que será nomeada como Modelos 4, 5 e 6). +""")) + +cells.append(nbf.v4.new_code_cell("""# 1. Filtro e Limpeza C-99A +df_c99 = df[df['Modelo'] == 'C-99A'].copy() +df_c99 = df_c99[df_c99['Localidade Decolagem'] != 0] +df_c99 = df_c99[df_c99['Localidade Pouso'] != 0] +df_c99['Trecho'] = df_c99['Localidade Decolagem'] + '-' + df_c99['Localidade Pouso'] +df_c99['PAX'] = pd.to_numeric(df_c99['PAX']).fillna(0) +df_c99['Dep TimeStamp'] = pd.to_datetime(df_c99['Data de Decolagem'] + ' ' + df_c99['Hora de Decolagem'], format='mixed', dayfirst=True) +df_c99['Data Apenas'] = df_c99['Dep TimeStamp'].dt.date + +CAPACIDADE_C99 = 50 +matriculas_unicas_c99 = df_c99['Matrícula'].unique() +total_aeronaves_c99 = len(matriculas_unicas_c99) + +print(f"Total de matrículas únicas C-99A (aeronaves disponíveis): {total_aeronaves_c99}") + +# Demanda diária +demanda_diaria_c99 = df_c99.groupby(['Trecho', 'Data Apenas'])['PAX'].sum().reset_index() + +import itertools +todos_trechos_c99 = demanda_diaria_c99['Trecho'].unique() +idx_c99 = pd.MultiIndex.from_product([todos_trechos_c99, datas_2025], names=['Trecho', 'Data Apenas']) +demanda_diaria_completa_c99 = pd.DataFrame(index=idx_c99).reset_index() +demanda_diaria_completa_c99 = pd.merge(demanda_diaria_completa_c99, demanda_diaria_c99, on=['Trecho', 'Data Apenas'], how='left').fillna({'PAX': 0}) + +estatisticas_trechos_c99 = demanda_diaria_completa_c99.groupby('Trecho').agg( + Media_PAX_Diario=('PAX', 'mean'), + Desvio_Padrao_PAX=('PAX', 'std'), + Total_PAX=('PAX', 'sum'), + Dias_Operados=('PAX', lambda x: (x > 0).sum()) +).reset_index() + +estatisticas_trechos_c99['Media_PAX_Dias_Operados'] = estatisticas_trechos_c99.apply( + lambda row: row['Total_PAX'] / row['Dias_Operados'] if row['Dias_Operados'] > 0 else 0, axis=1 +) +estatisticas_trechos_c99['Score_Relevancia'] = estatisticas_trechos_c99['Total_PAX'] * estatisticas_trechos_c99['Dias_Operados'] +estatisticas_trechos_c99 = estatisticas_trechos_c99.sort_values(by='Score_Relevancia', ascending=False) + +NUM_TRECHOS_C99 = 10 +top_trechos_c99 = estatisticas_trechos_c99.head(NUM_TRECHOS_C99) + +display(top_trechos_c99) + +plt.figure(figsize=(10, 6)) +sns.barplot(data=top_trechos_c99, x='Trecho', y='Score_Relevancia', hue='Trecho', palette='magma', legend=False) +plt.title(f'Top {NUM_TRECHOS_C99} Trechos C-99A (PAX * Dias Operados)') +plt.xticks(rotation=45) +plt.tight_layout() +plt.show() + +# Rede C-99 +G_c99 = nx.DiGraph() +for _, row in top_trechos_c99.iterrows(): + origem, destino = row['Trecho'].split('-') + G_c99.add_edge(origem, destino, weight=row['Score_Relevancia']) +pos_c99 = nx.spring_layout(G_c99, k=2.5, iterations=100, seed=42) +plt.figure(figsize=(12, 8)) +nx.draw_networkx_nodes(G_c99, pos_c99, node_size=1200, node_color='lightcoral', edgecolors='black') +nx.draw_networkx_edges(G_c99, pos_c99, edgelist=G_c99.edges(), arrows=True, arrowstyle='-|>', arrowsize=25, edge_color='gray', width=2, node_size=1200, connectionstyle='arc3,rad=0.15') +nx.draw_networkx_labels(G_c99, pos_c99, font_size=12, font_weight='bold') +plt.title('Diagrama de Rede - C-99A', fontsize=14) +plt.axis('off') +plt.show() +""")) + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 4: Minimização de Distância (Custo) +Equivalente ao Modelo 1, mas para C-99A. +""")) + +cells.append(nbf.v4.new_code_cell("""# Preparação Modelo 4 +rotas_lista_c99 = top_trechos_c99['Trecho'].tolist() + +distancias_voo_c99 = {} +for r in rotas_lista_c99: + origem, destino = r.split('-') + distancias_voo_c99[r] = calc_distancia(origem, destino) + +voos_requeridos_c99 = {} +for _, row in top_trechos_c99.iterrows(): + voos = math.ceil(row['Media_PAX_Dias_Operados'] / CAPACIDADE_C99) + voos_requeridos_c99[row['Trecho']] = max(1, voos) + +prob4 = pulp.LpProblem("Fleet_Assignment_C99_Brasil", pulp.LpMinimize) +X_c99 = pulp.LpVariable.dicts("X_c99", rotas_lista_c99, lowBound=0, cat='Integer') + +prob4 += pulp.lpSum([distancias_voo_c99[r] * X_c99[r] for r in rotas_lista_c99]) + +for r in rotas_lista_c99: + prob4 += X_c99[r] >= voos_requeridos_c99[r] + +prob4 += pulp.lpSum([X_c99[r] for r in rotas_lista_c99]) <= total_aeronaves_c99 + +prob4.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("== MODELO 4 (C-99A) ==") +print(f"Status: {pulp.LpStatus[prob4.status]}") +print(f"Distância Total: {pulp.value(prob4.objective):.2f} km\\n") +for r in rotas_lista_c99: + print(f"Trecho: {r:10} | Alocados: {int(X_c99[r].varValue)} voo(s)") +""")) + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 5: Minimização de Frota C-99A (S/ TAT) +Equivalente ao Modelo 2. +""")) + +cells.append(nbf.v4.new_code_cell("""# Velocidade Média C-99A +df_c99_spd = df_c99.copy() +df_c99_spd['Tempo_Horas'] = pd.to_timedelta(df_c99_spd['Tempo de Voo']).dt.total_seconds() / 3600 +df_c99_spd['Dist_km'] = df_c99_spd.apply(get_dist_row, axis=1) +df_valid_c99 = df_c99_spd[(df_c99_spd['Tempo_Horas'] > 0) & (df_c99_spd['Dist_km'] > 0)].copy() +df_valid_c99['Velocidade'] = df_valid_c99['Dist_km'] / df_valid_c99['Tempo_Horas'] +vel_media_c99 = df_valid_c99['Velocidade'].mean() +print(f"Velocidade média C-99A: {vel_media_c99:.2f} km/h") + +aeroportos_malha_c99 = set() +for r in rotas_lista_c99: + o, d = r.split('-') + aeroportos_malha_c99.add(o) + aeroportos_malha_c99.add(d) +aeroportos_malha_c99 = list(aeroportos_malha_c99) + +tempos_voo_min_c99 = {} +for o in aeroportos_malha_c99: + for d in aeroportos_malha_c99: + if o == d: + tempos_voo_min_c99[(o, d)] = 0 + else: + dist = calc_distancia(o, d) + tempos_voo_min_c99[(o, d)] = int(round((dist / vel_media_c99) * 60)) + +D_c99 = {(o, d): 0 for o in aeroportos_malha_c99 for d in aeroportos_malha_c99} +for r in rotas_lista_c99: + o, d = r.split('-') + D_c99[(o, d)] = voos_requeridos_c99[r] + +prob5 = pulp.LpProblem("Minimizar_Aeronaves_C99", pulp.LpMinimize) +Y5 = pulp.LpVariable.dicts("Y5", [(o, d) for o in aeroportos_malha_c99 for d in aeroportos_malha_c99], lowBound=0, cat='Integer') +N5 = pulp.LpVariable("N5", lowBound=0, cat='Integer') + +prob5 += N5 + 0.0001 * pulp.lpSum([Y5[(i, j)] * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) + +for no in aeroportos_malha_c99: + chegadas = pulp.lpSum([D_c99[(i, no)] + Y5[(i, no)] for i in aeroportos_malha_c99]) + partidas = pulp.lpSum([D_c99[(no, j)] + Y5[(no, j)] for j in aeroportos_malha_c99]) + prob5 += chegadas == partidas + +tempo_total_voo_c99 = pulp.lpSum([(D_c99[(i, j)] + Y5[(i, j)]) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) +prob5 += tempo_total_voo_c99 <= N5 * 1440 + +prob5.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("\\n== RESULTADO DO MODELO 5 (C-99A) ==") +print(f"Status: {pulp.LpStatus[prob5.status]}") +print(f"Aeronaves mínimas: {int(N5.varValue)}") + +tempo_gasto_c99 = sum([(D_c99[(i, j)] + int(Y5[(i, j)].varValue)) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) +print(f"Tempo total de voo: {int(tempo_gasto_c99)} min ({tempo_gasto_c99/60:.2f} h)\\n") + +voos_para_fazer_c99 = [] +D_copy_c99 = {k: v for k, v in D_c99.items()} +for i in aeroportos_malha_c99: + for j in aeroportos_malha_c99: + total_voos = D_c99[(i, j)] + int(Y5[(i, j)].varValue) + for _ in range(total_voos): + if D_copy_c99[(i, j)] > 0: + tipo = 'Passageiro' + D_copy_c99[(i, j)] -= 1 + else: + tipo = 'Vazio' + voos_para_fazer_c99.append({'origem': i, 'destino': j, 'tipo': tipo, 'tempo': tempos_voo_min_c99[(i, j)]}) + +tabela_horarios_c99 = [] +aeronave_id = 1 + +while voos_para_fazer_c99: + voo_atual = voos_para_fazer_c99.pop(0) + hora_atual = datetime.datetime(2025, 1, 1, 0, 0, 0) + tempo_delta = datetime.timedelta(minutes=int(voo_atual['tempo'])) + hora_chegada = hora_atual + tempo_delta + + tabela_horarios_c99.append([f"Aeronave {aeronave_id}", voo_atual['origem'], voo_atual['destino'], voo_atual['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f"{voo_atual['tempo']} min"]) + hora_atual = hora_chegada + local_atual = voo_atual['destino'] + + while True: + prox_voo = None + for idx, v in enumerate(voos_para_fazer_c99): + if v['origem'] == local_atual: + if (hora_atual - datetime.datetime(2025, 1, 1, 0, 0, 0) + datetime.timedelta(minutes=int(v['tempo']))).total_seconds() <= 1440 * 60: + prox_voo = voos_para_fazer_c99.pop(idx) + break + if prox_voo: + tempo_delta = datetime.timedelta(minutes=int(prox_voo['tempo'])) + hora_chegada = hora_atual + tempo_delta + tabela_horarios_c99.append([f"Aeronave {aeronave_id}", prox_voo['origem'], prox_voo['destino'], prox_voo['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f"{prox_voo['tempo']} min"]) + hora_atual = hora_chegada + local_atual = prox_voo['destino'] + else: + break + aeronave_id += 1 + +print(tabulate(tabela_horarios_c99, headers=["Aeronave", "Origem", "Destino", "Tipo", "Partida", "Chegada", "Duração"], tablefmt="github")) +""")) + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 6: Minimização de Frota C-99A (C/ 40 min TAT) +Equivalente ao Modelo 3. +""")) + +cells.append(nbf.v4.new_code_cell("""# Modelo 6 +prob6 = pulp.LpProblem("Minimizar_Aeronaves_C99_TAT", pulp.LpMinimize) +Y6 = pulp.LpVariable.dicts("Y6", [(o, d) for o in aeroportos_malha_c99 for d in aeroportos_malha_c99], lowBound=0, cat='Integer') +N6 = pulp.LpVariable("N6", lowBound=0, cat='Integer') + +TAT_min = 40 + +prob6 += N6 + 0.0001 * pulp.lpSum([Y6[(i, j)] * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) + +for no in aeroportos_malha_c99: + chegadas = pulp.lpSum([D_c99[(i, no)] + Y6[(i, no)] for i in aeroportos_malha_c99]) + partidas = pulp.lpSum([D_c99[(no, j)] + Y6[(no, j)] for j in aeroportos_malha_c99]) + prob6 += chegadas == partidas + +tempo_total_op_c99 = pulp.lpSum([(D_c99[(i, j)] + Y6[(i, j)]) * (tempos_voo_min_c99[(i, j)] + TAT_min) for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) +prob6 += tempo_total_op_c99 <= N6 * 1440 + +prob6.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("\\n== RESULTADO DO MODELO 6 (C-99A C/ TAT 40 MIN) ==") +print(f"Status: {pulp.LpStatus[prob6.status]}") +print(f"Aeronaves mínimas: {int(N6.varValue)}") + +tempo_voo_c99_6 = sum([(D_c99[(i, j)] + int(Y6[(i, j)].varValue)) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) +tot_voos_6 = sum([(D_c99[(i, j)] + int(Y6[(i, j)].varValue)) for i in aeroportos_malha_c99 for j in aeroportos_malha_c99]) +solo_tot_6 = tot_voos_6 * TAT_min + +print(f"Tempo total operacional comprometido: {tempo_voo_c99_6 + solo_tot_6} min ({(tempo_voo_c99_6 + solo_tot_6)/60:.2f} h)\\n") + +voos_para_fazer_c99_6 = [] +D_copy_c99_6 = {k: v for k, v in D_c99.items()} +for i in aeroportos_malha_c99: + for j in aeroportos_malha_c99: + tot = D_c99[(i, j)] + int(Y6[(i, j)].varValue) + for _ in range(tot): + if D_copy_c99_6[(i, j)] > 0: + tipo = 'Passageiro' + D_copy_c99_6[(i, j)] -= 1 + else: + tipo = 'Vazio' + voos_para_fazer_c99_6.append({'origem': i, 'destino': j, 'tipo': tipo, 'tempo': tempos_voo_min_c99[(i, j)]}) + +tabela_horarios_c99_6 = [] +aeronave_id = 1 + +while voos_para_fazer_c99_6: + voo_atual = voos_para_fazer_c99_6.pop(0) + hora_atual = datetime.datetime(2025, 1, 1, 0, 0, 0) + tempo_delta = datetime.timedelta(minutes=int(voo_atual['tempo'])) + hora_chegada = hora_atual + tempo_delta + + tabela_horarios_c99_6.append([f"Aeronave {aeronave_id}", voo_atual['origem'], voo_atual['destino'], voo_atual['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f"{voo_atual['tempo']} min"]) + hora_atual = hora_chegada + datetime.timedelta(minutes=40) + local_atual = voo_atual['destino'] + + while True: + prox_voo = None + for idx, v in enumerate(voos_para_fazer_c99_6): + if v['origem'] == local_atual: + if (hora_atual - datetime.datetime(2025, 1, 1, 0, 0, 0) + datetime.timedelta(minutes=int(v['tempo']))).total_seconds() <= 1440 * 60: + prox_voo = voos_para_fazer_c99_6.pop(idx) + break + if prox_voo: + tempo_delta = datetime.timedelta(minutes=int(prox_voo['tempo'])) + hora_chegada = hora_atual + tempo_delta + tabela_horarios_c99_6.append([f"Aeronave {aeronave_id}", prox_voo['origem'], prox_voo['destino'], prox_voo['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f"{prox_voo['tempo']} min"]) + hora_atual = hora_chegada + datetime.timedelta(minutes=40) + local_atual = prox_voo['destino'] + else: + break + aeronave_id += 1 + +print(tabulate(tabela_horarios_c99_6, headers=["Aeronave", "Origem", "Destino", "Tipo", "Partida", "Chegada", "Duração"], tablefmt="github")) +""")) + nb.cells = cells with open('modelos.ipynb', 'w', encoding='utf-8') as f: diff --git a/modelos.ipynb b/modelos.ipynb index 4d754b7..34b8c11 100644 --- a/modelos.ipynb +++ b/modelos.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "79f9c4cd", + "id": "f5ec4bcf", "metadata": {}, "source": [ "# Alocação de Frotas (Fleet Scheduling) - Aeronaves C-97\n", @@ -21,13 +21,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "54f43903", + "id": "6697b12b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:22.236217Z", - "iopub.status.busy": "2026-06-07T23:48:22.236030Z", - "iopub.status.idle": "2026-06-07T23:48:22.868108Z", - "shell.execute_reply": "2026-06-07T23:48:22.867334Z" + "iopub.execute_input": "2026-06-07T23:57:33.054677Z", + "iopub.status.busy": "2026-06-07T23:57:33.054015Z", + "iopub.status.idle": "2026-06-07T23:57:33.693276Z", + "shell.execute_reply": "2026-06-07T23:57:33.690940Z" } }, "outputs": [], @@ -53,7 +53,7 @@ }, { "cell_type": "markdown", - "id": "56cb48ea", + "id": "78257a48", "metadata": {}, "source": [ "## 1. Leitura e Limpeza dos Dados\n", @@ -63,13 +63,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "47598c7a", + "id": "aa079637", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:22.869683Z", - "iopub.status.busy": "2026-06-07T23:48:22.869463Z", - "iopub.status.idle": "2026-06-07T23:48:23.259672Z", - "shell.execute_reply": "2026-06-07T23:48:23.259069Z" + "iopub.execute_input": "2026-06-07T23:57:33.695046Z", + "iopub.status.busy": "2026-06-07T23:57:33.694816Z", + "iopub.status.idle": "2026-06-07T23:57:34.087298Z", + "shell.execute_reply": "2026-06-07T23:57:34.086363Z" } }, "outputs": [], @@ -101,7 +101,7 @@ }, { "cell_type": "markdown", - "id": "6c58dbc1", + "id": "06d31f16", "metadata": {}, "source": [ "## 2. Análise dos Esquadrões e Matrículas (Aeronaves)\n", @@ -111,13 +111,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "5a0bbad7", + "id": "336f2956", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:23.261299Z", - "iopub.status.busy": "2026-06-07T23:48:23.261168Z", - "iopub.status.idle": "2026-06-07T23:48:23.273090Z", - "shell.execute_reply": "2026-06-07T23:48:23.272489Z" + "iopub.execute_input": "2026-06-07T23:57:34.088770Z", + "iopub.status.busy": "2026-06-07T23:57:34.088637Z", + "iopub.status.idle": "2026-06-07T23:57:34.101734Z", + "shell.execute_reply": "2026-06-07T23:57:34.101186Z" } }, "outputs": [ @@ -176,7 +176,7 @@ }, { "cell_type": "markdown", - "id": "112d4888", + "id": "339dec26", "metadata": {}, "source": [ "## 3. Análise Estatística das Demandas Diárias\n", @@ -187,13 +187,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "fcd3f8cd", + "id": "016363d5", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:23.274563Z", - "iopub.status.busy": "2026-06-07T23:48:23.274434Z", - "iopub.status.idle": "2026-06-07T23:48:23.596693Z", - "shell.execute_reply": "2026-06-07T23:48:23.596151Z" + "iopub.execute_input": "2026-06-07T23:57:34.103227Z", + "iopub.status.busy": "2026-06-07T23:57:34.103108Z", + "iopub.status.idle": "2026-06-07T23:57:34.429121Z", + "shell.execute_reply": "2026-06-07T23:57:34.428557Z" } }, "outputs": [ @@ -424,7 +424,7 @@ }, { "cell_type": "markdown", - "id": "13a07f72", + "id": "3c77b9ad", "metadata": {}, "source": [ "## Diagrama de Rede dos Trechos\n", @@ -434,13 +434,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "cebc71a4", + "id": "cf0a41c4", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:23.598286Z", - "iopub.status.busy": "2026-06-07T23:48:23.598153Z", - "iopub.status.idle": "2026-06-07T23:48:23.718347Z", - "shell.execute_reply": "2026-06-07T23:48:23.717643Z" + "iopub.execute_input": "2026-06-07T23:57:34.430584Z", + "iopub.status.busy": "2026-06-07T23:57:34.430456Z", + "iopub.status.idle": "2026-06-07T23:57:34.558385Z", + "shell.execute_reply": "2026-06-07T23:57:34.555014Z" } }, "outputs": [ @@ -497,7 +497,7 @@ }, { "cell_type": "markdown", - "id": "561a020b", + "id": "b674c60e", "metadata": {}, "source": [ "## 4. Fleet Assignment Model (FAM) - Nível Brasil\n", @@ -514,13 +514,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "191b2c03", + "id": "7ced35c2", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:23.719928Z", - "iopub.status.busy": "2026-06-07T23:48:23.719652Z", - "iopub.status.idle": "2026-06-07T23:48:23.746255Z", - "shell.execute_reply": "2026-06-07T23:48:23.745701Z" + "iopub.execute_input": "2026-06-07T23:57:34.560156Z", + "iopub.status.busy": "2026-06-07T23:57:34.560010Z", + "iopub.status.idle": "2026-06-07T23:57:34.585094Z", + "shell.execute_reply": "2026-06-07T23:57:34.584521Z" } }, "outputs": [ @@ -609,7 +609,7 @@ }, { "cell_type": "markdown", - "id": "b16a0622", + "id": "561bc1a2", "metadata": {}, "source": [ "## 5. Modelo 2: Minimização de Aeronaves\n", @@ -623,13 +623,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "c24cc47b", + "id": "77540075", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:23.747882Z", - "iopub.status.busy": "2026-06-07T23:48:23.747749Z", - "iopub.status.idle": "2026-06-07T23:48:25.090530Z", - "shell.execute_reply": "2026-06-07T23:48:25.089931Z" + "iopub.execute_input": "2026-06-07T23:57:34.586622Z", + "iopub.status.busy": "2026-06-07T23:57:34.586482Z", + "iopub.status.idle": "2026-06-07T23:57:35.973784Z", + "shell.execute_reply": "2026-06-07T23:57:35.973311Z" } }, "outputs": [ @@ -651,17 +651,17 @@ "== QUADRO DE HORÁRIOS DIÁRIOS ==\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", "|------------|----------|-----------|--------------------------|-----------|-----------|-----------|\n", - "| Aeronave 1 | SBSJ | SBGL | Passageiro | 00:00 | 00:42 | 42 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 00:42 | 01:24 | 42 min |\n", - "| Aeronave 1 | SBSJ | SBBR | Passageiro | 01:24 | 03:33 | 129 min |\n", - "| Aeronave 1 | SBBR | SBGL | Passageiro | 03:33 | 05:53 | 140 min |\n", - "| Aeronave 1 | SBGL | SBBR | Passageiro | 05:53 | 08:13 | 140 min |\n", - "| Aeronave 1 | SBBR | SBAN | Passageiro | 08:13 | 08:31 | 18 min |\n", - "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 08:31 | 10:40 | 129 min |\n", - "| Aeronave 2 | SBGL | SBGR | Passageiro | 00:00 | 00:52 | 52 min |\n", - "| Aeronave 2 | SBGR | SBGL | Passageiro | 00:52 | 01:44 | 52 min |\n", - "| Aeronave 3 | SBBR | SBGR | Passageiro | 00:00 | 02:10 | 130 min |\n", - "| Aeronave 3 | SBGR | SBBR | Passageiro | 02:10 | 04:20 | 130 min |\n" + "| Aeronave 1 | SBSJ | SBBR | Passageiro | 00:00 | 02:09 | 129 min |\n", + "| Aeronave 1 | SBBR | SBGR | Passageiro | 02:09 | 04:19 | 130 min |\n", + "| Aeronave 1 | SBGR | SBBR | Passageiro | 04:19 | 06:29 | 130 min |\n", + "| Aeronave 1 | SBBR | SBAN | Passageiro | 06:29 | 06:47 | 18 min |\n", + "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 06:47 | 08:56 | 129 min |\n", + "| Aeronave 1 | SBSJ | SBGL | Passageiro | 08:56 | 09:38 | 42 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 09:38 | 10:20 | 42 min |\n", + "| Aeronave 2 | SBBR | SBGL | Passageiro | 00:00 | 02:20 | 140 min |\n", + "| Aeronave 2 | SBGL | SBBR | Passageiro | 02:20 | 04:40 | 140 min |\n", + "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:52 | 52 min |\n", + "| Aeronave 3 | SBGL | SBGR | Passageiro | 00:52 | 01:44 | 52 min |\n" ] } ], @@ -835,7 +835,7 @@ }, { "cell_type": "markdown", - "id": "f18a2ffb", + "id": "c700c020", "metadata": {}, "source": [ "## 6. Modelo 3: Minimização de Aeronaves com TAT (Turnaround Time)\n", @@ -848,13 +848,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "13888b4d", + "id": "4b875ed9", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:48:25.091858Z", - "iopub.status.busy": "2026-06-07T23:48:25.091719Z", - "iopub.status.idle": "2026-06-07T23:48:25.108636Z", - "shell.execute_reply": "2026-06-07T23:48:25.108109Z" + "iopub.execute_input": "2026-06-07T23:57:35.975498Z", + "iopub.status.busy": "2026-06-07T23:57:35.975366Z", + "iopub.status.idle": "2026-06-07T23:57:35.993825Z", + "shell.execute_reply": "2026-06-07T23:57:35.993344Z" } }, "outputs": [ @@ -874,17 +874,17 @@ "== QUADRO DE HORÁRIOS DIÁRIOS (COM 40 MIN TAT) ==\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração Voo |\n", "|------------|----------|-----------|--------------------------|-----------|-----------|---------------|\n", - "| Aeronave 1 | SBSJ | SBGL | Passageiro | 00:00 | 00:42 | 42 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 01:22 | 02:04 | 42 min |\n", - "| Aeronave 1 | SBSJ | SBBR | Passageiro | 02:44 | 04:53 | 129 min |\n", - "| Aeronave 1 | SBBR | SBGL | Passageiro | 05:33 | 07:53 | 140 min |\n", - "| Aeronave 1 | SBGL | SBBR | Passageiro | 08:33 | 10:53 | 140 min |\n", - "| Aeronave 1 | SBBR | SBAN | Passageiro | 11:33 | 11:51 | 18 min |\n", - "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 12:31 | 14:40 | 129 min |\n", - "| Aeronave 2 | SBGL | SBGR | Passageiro | 00:00 | 00:52 | 52 min |\n", - "| Aeronave 2 | SBGR | SBGL | Passageiro | 01:32 | 02:24 | 52 min |\n", - "| Aeronave 3 | SBBR | SBGR | Passageiro | 00:00 | 02:10 | 130 min |\n", - "| Aeronave 3 | SBGR | SBBR | Passageiro | 02:50 | 05:00 | 130 min |\n" + "| Aeronave 1 | SBSJ | SBBR | Passageiro | 00:00 | 02:09 | 129 min |\n", + "| Aeronave 1 | SBBR | SBGR | Passageiro | 02:49 | 04:59 | 130 min |\n", + "| Aeronave 1 | SBGR | SBBR | Passageiro | 05:39 | 07:49 | 130 min |\n", + "| Aeronave 1 | SBBR | SBAN | Passageiro | 08:29 | 08:47 | 18 min |\n", + "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 09:27 | 11:36 | 129 min |\n", + "| Aeronave 1 | SBSJ | SBGL | Passageiro | 12:16 | 12:58 | 42 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 13:38 | 14:20 | 42 min |\n", + "| Aeronave 2 | SBBR | SBGL | Passageiro | 00:00 | 02:20 | 140 min |\n", + "| Aeronave 2 | SBGL | SBBR | Passageiro | 03:00 | 05:20 | 140 min |\n", + "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:52 | 52 min |\n", + "| Aeronave 3 | SBGL | SBGR | Passageiro | 01:32 | 02:24 | 52 min |\n" ] } ], @@ -998,6 +998,636 @@ "print(\"== QUADRO DE HORÁRIOS DIÁRIOS (COM 40 MIN TAT) ==\")\n", "print(tabulate(tabela_horarios3, headers=[\"Aeronave\", \"Origem\", \"Destino\", \"Tipo\", \"Partida\", \"Chegada\", \"Duração Voo\"], tablefmt=\"github\"))\n" ] + }, + { + "cell_type": "markdown", + "id": "bcb47486", + "metadata": {}, + "source": [ + "# Alocação de Frotas - Aeronaves C-99A\n", + "Agora replicaremos a mesma lógica e os mesmos modelos (1, 2 e 3) para a aeronave C-99A (que será nomeada como Modelos 4, 5 e 6).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "286bd66c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-07T23:57:35.995282Z", + "iopub.status.busy": "2026-06-07T23:57:35.995152Z", + "iopub.status.idle": "2026-06-07T23:57:36.342199Z", + "shell.execute_reply": "2026-06-07T23:57:36.341657Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total de matrículas únicas C-99A (aeronaves disponíveis): 5\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TrechoMedia_PAX_DiarioDesvio_Padrao_PAXTotal_PAXDias_OperadosMedia_PAX_Dias_OperadosScore_Relevancia
48SBBR-SBGL3.0383569.5858561109.05619.80357162104.0
127SBGL-SBBR3.07945210.2807691124.05022.48000056200.0
158SBGR-SBBR0.8465754.933461309.02015.4500006180.0
50SBBR-SBGR0.6849324.424820250.01714.7058824250.0
136SBGL-SBGR0.5643843.161295206.01712.1176473502.0
31SBBR-SBAF0.5945214.223166217.01119.7272732387.0
0SBAF-SBBR0.4958903.539124181.0822.6250001448.0
61SBBR-SBSJ0.3863013.265929141.01014.1000001410.0
144SBGL-SBSJ0.2356162.07797086.099.555556774.0
163SBGR-SBGL0.1479451.12172754.0143.857143756.0
\n", + "
" + ], + "text/plain": [ + " Trecho Media_PAX_Diario Desvio_Padrao_PAX Total_PAX Dias_Operados \\\n", + "48 SBBR-SBGL 3.038356 9.585856 1109.0 56 \n", + "127 SBGL-SBBR 3.079452 10.280769 1124.0 50 \n", + "158 SBGR-SBBR 0.846575 4.933461 309.0 20 \n", + "50 SBBR-SBGR 0.684932 4.424820 250.0 17 \n", + "136 SBGL-SBGR 0.564384 3.161295 206.0 17 \n", + "31 SBBR-SBAF 0.594521 4.223166 217.0 11 \n", + "0 SBAF-SBBR 0.495890 3.539124 181.0 8 \n", + "61 SBBR-SBSJ 0.386301 3.265929 141.0 10 \n", + "144 SBGL-SBSJ 0.235616 2.077970 86.0 9 \n", + "163 SBGR-SBGL 0.147945 1.121727 54.0 14 \n", + "\n", + " Media_PAX_Dias_Operados Score_Relevancia \n", + "48 19.803571 62104.0 \n", + "127 22.480000 56200.0 \n", + "158 15.450000 6180.0 \n", + "50 14.705882 4250.0 \n", + "136 12.117647 3502.0 \n", + "31 19.727273 2387.0 \n", + "0 22.625000 1448.0 \n", + "61 14.100000 1410.0 \n", + "144 9.555556 774.0 \n", + "163 3.857143 756.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAAJICAYAAACaO0yGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhU1JREFUeJzt3QmcleP///FP+54lqb6IlDbt2mmxJVRkKxRShJBIoggVSZsilTaVvoVSliRlTVoQpY20iPZ93+//4339vvf5n5lmplnuM8uZ1/PxmGbmnDOnM9e5576vz3V9rs+VxfM8zwAAAAAAQIpkTdmPAwAAAAAAAmwAAAAAAALCDDYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABIB3r2rWrlSlTJsGP1q1bp9rrefzxx91riu348eM2aNAga9CggVWuXNnuuusu++233+J9nqlTp57299JHpOn/GDJkiKWlLVu2WN++fa1x48au7a644gp76KGH7KeffkrUz+/bt8969OhhdevWtSpVqtidd95pP/zwQ5xt3qRJE6tYsaJdffXV9uabb7r3LS7r1q1zbVOrVi07evRoon+Xf/75x6688krbuXOn+/6qq6465T3V/3/ttdda//797ciRIzF+/uTJk9awYUP3uN9///2U51+1apX7+bZt25rneafc36dPH3f/8uXLE3yd+vlPPvnktL9P7Ndevnx51yb333+/ff3116f87nqM2jk16H0ZP3683X777VatWjX30bx5cxs9erQdOnTIMgr9/QX9t75r1y53HG3YsCHQ5wWAxMieqEcBANLEI488Yi1btgx9P3ToUBc8KDjy5c+fP+KvQ4HPq6++al988YXrxMcV2Hz44Yf21FNP2XnnnWdjxoyx++67z6ZNm2YXXnjhKY9X53fy5Mmh77/55ht7++233e9VuHBhyyx+/vln69Chg5111ll2zz33WIkSJWz37t2ubTRwoja/+eab4/15Bchq5zVr1tjDDz9sFSpUsPnz51v79u3dgMc111zjHvfuu+/aK6+8Ytddd509/fTTLgAZPHiwC1jjGmCYMmWKlSxZ0tavX28zZ860Zs2anfZ3UcD77LPP2r333mtnn3126HYNuug49imoXrBggTuW//33XxswYEDoPg0MbN++3S6++GKbNGmS9erVK8b/oUDsySefdMfbe++9Z61atQrdN3v2bHfcPf/88y4QjouO0Vy5crm/mSxZstjw4cPdgEDp0qXj/b1uu+02F8TKsWPHbNu2ba59NAjSrVs3977Jueee69634sWLW6RpUOWBBx6wlStXugEVDXzp99GgjP6OPvroI3vnnXesaNGilhnp70l/F88995yNGzfOtQ0ApBoPAJBhPPPMM96VV16Zqv/nihUrvLvvvturVKmS+9BrCLdx40avfPny3nvvvRe67ciRI17Dhg29bt26Jer/mDJlile6dGlvw4YNXmrS/zl48GAvLezatcu74oorvBYtWngHDx6Mcd+JEye8tm3behUrVvS2bdsW73PMmjXL/Q7Tp0+PcXufPn28+vXru+c5fvy4V7NmTa9NmzYxHrNq1Sr3s3Pnzo1xux6v1zVkyBDv/vvv9+68885E/T5ffPGF+3/03vt0rMY+XnzPPvusV6ZMGW/Lli2h25544gmvVatW3vDhw70qVap4+/btO+XnTp486d17773uWFy9erW7TcdNjRo1vA4dOiT4GidMmOCOZR2vtWvX9h577DHv119/Tdbx8eijj3qXXnppqh+zotddrVo197cZ25o1a7xatWq531Ntld6pfdXOQdNxqONRxyUApCZSxAEgCmjmT2nZl112mUth1Uzypk2bTknJVtq2ZqArVapkTZs2dbOTp/PMM8/YiRMn3OxcoUKFTrn/xx9/dDOpSvv15cyZ081Sf/vttyn6vfy0W81M+inUmj2UP/74w83U+umxmgmOnRK6detW9/rr1KljVatWdTOeixcvjvGY/fv3u5nImjVrusdoNlCzqOFmzJhht9xyi7v/8ssvtxdeeMH27NkTuv/w4cP24osvWv369d0ssl7rqFGjEvzdNLuv16dZtjx58sS4L2vWrNa5c2e7++673euLz19//RVKxQ6nY2Dz5s1uhlq/i2bF9X6E06ytZvqUPRBu7ty57nXp8Zq51iz76tWr7XQ0G6wZcr33iaF20qy3f5yqPTULrRllpbIrzXn69Omn/JxmI1977TU3E63ZeM2I63jPly+f9e7dO8H/U+2pjIBLLrnEcufO7X5ex1RydOrUyc1oa1Y8vhTxRYsWuXT0GjVquN9X75MyBpQR4vv0009dO+tvsnbt2u5917KB+Pz5558uk0THftmyZU+5X1kQHTt2dP+3shmS8vevttRyBWUd6PXqMTr2w+l3UDaEMhX0PPrbEc2mP/roo+53uPTSS61evXouA0F/G+HPr6wM/Q3pb0kZD7GXCSTmfKb2GzhwoHstfrtqyYHeD5+OQx2POi4BIDURYANABqdATWtCixUr5tJt1WlVENmiRQvbsWNHjMeqU+6vv1VH/IknnjhtEKwO93//+984O/N+kKfgJnZqt1LDFagdOHAgxb+jghKlxOq1qHO+du1alzqv30/BlgIrBddKl/V/Z/2/+l7pyAqk9DsrKFNbaY2xTymk6pi/8cYbriP/1Vdf2csvvxy6X6nMSkvW+malVSuQV4CjFG4/eFDA8d1337lgXoG12liv1R8MiMv3339v55xzjgtS4qL21vNddNFF8T6HAmRRqnW4v//+231WmxQsWNCyZ89uGzdujPEYBbR79+49ZVBCr1kBqAKXRo0aufdW6doJUYq61kzr8Yml91AuuOAC91lrojWQo6DuP//5jwvUwpcRhCtSpIgb0Fi2bJk7DvR/K8A644wzEvw/Fcwp4FLgd/3117v1ysmlNHa9Tg1AxEUBp9KUzzzzTBcMKnW7evXq7jj8/PPP3WP0s126dHHtppRu/e0qKNZxmNBxE9egSrgbbrjBDUTMmTMn0X//GuzQsa33uk2bNu71KgjWQILOMeGUnq+17vrbUAq9/s41eKFBEaXv63e58cYb3Rpx/X359Hf4/vvvh5Yw6BgcO3Zsks9nen6dk/R69R7q71x/d3rN4TTQpWPDP9YAIDWwBhsAMjDN5PTr188VxlKA4dOMrjrZ6nSqA+9TUKhOqWiGSbNZb731lpuxis/pChBpPWhc68AVmIlmYP2vk0vB0K233hr6XgGIZn3VOff/b81Sa83xyJEjXWCqdagKPPW5XLlyoXbRDKZm9/zAVYGCgmH/OTTL5wcdCgDUab/jjjvcrHX47K8CCgWj+rxw4UIX+CuoEM265c2bN84Zf59mmLVePSWUNaD3X7+vBgUU9Gkdrj97fvDgQddOar8JEyZYqVKl3M8oUNGgRLZs2WIUxNLabA0waEBB9LM6jjST7Ld5XPyZ0rgGCxS4hRdT0/+twQgFcnpuf722ZlmVAeAP1ChjQAHZL7/84t632PSzClRnzZrlZlPjekxsGmD57LPP3Oym3sMcOXJYSmiAJHa2Q3iArcJzr7/+ustIEB0jal8N+uhYUYCtmfQHH3wwNPOvgHzp0qWu3eJaO6yZckno2NFAgz5iD7wk9Pc/b948F7xrMEBt6z9Gx4eOMWUVaKBGNLCgmfbwrAf9jWmQyv971O+umWj9rvr9/Jl3DYwoIPafXwMqfoZEYs9n+nvTAJB/TlD2iY7NAgUKxPh99bftZ9loQAEAUgMz2ACQgWlmRkWX1PkNp0JLmn1SRzRceIEydd4VbC1ZsiRGGmdSxVXNOZwfXKSEHyCHB3TqVCs4UfCmD3XsNUOoQEEUvJx//vkxfladcHXy/aJVojTUcPoZzezKr7/+6qo1x25f/T8KcPz2VUCtmTnNsiuQ1aywApnYadnhFNxqxjYx/CA1/EO3KTjVDJ6eR7+TfhfNpmvW0f995aWXXnJpyN27d3ftpuNAx4dSecOD5o8//tg9l1632kAfOkb0OXaqcDh/plwfsWlGUv+P/6EgWkGWZlJV/dwPRjUbrZlc///VDLYGKeKbxdZxr/dYx7He0/CU/YT4gaw+p7T4VXxBsGggRzOtyo7Q76fXqAwIta+fyqzUcQWwOr4UUGpwRMGlUq3je17/780PduOj+2P/bSb0968gVLcp2A4/zjRTrrZWgBzf36Nes457DWAoWNbMuQamVE3er0LvV8UPn3nXuUFp3Ek9n+nvzU8j14Ca/k8t/7jpppti/JwCbh2T/qAEAKQGZrABIAPT2lp/Ji023RZ7uyJVOg6nGVZ1whXQKFhNDgW2caWB+2uHY88qJYcCrdi/twK+uII+f0ZUj0loBjm+51an3w9M/KAtvvbV7L1oHaoqNitA7dmzp/tQQKBAMr7Ues0CKrhJiNadKlVWgYVfrdqn1FsFGpqlU3q11u0qWFNqvj+j7KdMK4NAgbdep1LF9X/rNq0fDq/yrllkzSJqxjs2zTiHZxHEfq/jm93Wmmp/1lQBnB6nwYnw481fx6x0YH2E0yy11qmHp3/rNWomUwGgZk2V6qwMA32dmpSFEF8FcgWtOg40+6/XqYEbHRPhga++HzFihMvEUJ0Bfa3jShXK49t+z5+51ux0fMsH9H4ouI09y53Q37/+XvR1fJkASgP3A+vYfzN6P5TOrdRxZU3omFU2gwJun/+35C9r8IUvLUns+axdu3bu+FUGiWa8lSWgZQ0aQNLATDgdbwnVMQCAoBFgA0AGpnRSiStNVTNBsTuz6sCGd171c5pJ9Z8nOZSW7Hfow7dn0hZPsQOpoChoVwqq1orG5s/s6TFxzVwp5VjBmrahOh0/qPO3jordvv76Yc2GapssfSiA1R7JWp+qtGqlJMdF6bF6nNKB/VTWcCtWrHCzoAo4tc7VD0J9SnlVSreKlGnWUeuSfQpEFMz6AZH+H83kaYZbgYifqq0A0d/SSjPImmlVkTfN0If78ssv3XpavabYs5ei48wfbIhNx1Zcv59PM5waINDsdfi2W6L3T8G10vy1ntmnQFSZCkpn1gyo1uxqJlMDBEotTw2aNdUxoCUCcVEKvmattdZYx6oflGoZQuzjwE/F1sCIBk60RlzF1+JKudcMsAJKFShTIB4XvV8KepUlkNi/f/296DWGr5kOF9d2ez5/kECZEnof/UE1Hbc+/1yk/1MDPOGvKannMw2Cqd31oeNYSzqGDRtmjz32mJvZDi+0p8GD2OdBAIgkUsQBIANTkKUZIFUijp2yq/Tm2LNRqtLs02yV1q8q6Eps5ee4KHiQ8IrECpoU+GnNaSQozVkBjoI9BW/60JpMdfIVXIiCRLVDeGqrilypEx47WI2Pghy1Tez2VbqrAmm1r2YqFeT5BbMUPKjjrzW2sQuLhVPKtt47VVWOnaKvNGLNzGmNsGaTlSXg/57+h27z957W++hTNoHS1ZV+7A8QaPbZX2fu097YCq40wyyaDdSMo9Yza2Y8/EOVsBXUqLBUXPQ7a+YysWna4bQmWUGWipXF/n81Y65Z2vA0cQ2QqOidAml/rbCqZitTQIFp7KJtkaJ0bw0exbUvvCh9Xb+D6gL4wbUKbmkgyq8irgJ9+h31PmqmVe+F1tNLfMeOBnqUQq1ibXq+2PT769jR7Hjs2dyE/v71N6X3ULeHH2eq1q912uHr6OP6XbW+X7+LH1wro0I/6/+u/muJXblcgz9JPZ/pWPH3SNcsvI4F/c0pmA6frdbxqIGL8IAeACKNGWwAyMAU9KgglYIszZYqaNOspqoEK7iKPcOrIEtBpjqyH3zwgasArkArJTRLrSBDgaKeWwGR0l3V2VUqZyQ88sgjrpOtasQqmKTAUEGYAggFPqJOt2ZdNausWVnNYvkVw7V2MzE0o6YCTQowFOwqANKsqlKRFVDo91aQpbXFanM9RkXhtJZUs67h60tjUyCiistab6v105q9VdtpVlmptkof17rc8Jnp2JQxoEBes6R6HfpegZfSecOLRCndWEGy0sQ1A6r1tnqc1oxrfasGRBTUaO11XAXrlPKrAEwzzUrNjv0YfyBFgVZC1a3josBeQVLsYNCnY1rvqYplaUBFxbUUMCkd2KcAUUGlXxhN7afBgyDo/VBwJwoyFTjqvVVhLxWW09KAuGj2WentGpRQtoSyA7QuWZkFfmE5/c76W+natav7PXVsaiZex1187SFaeqD3WMeMjmW1v84Fqratv2fNUitlO3b9g4T+/pUFoUEZ/W3pQ69Zx6DaXjPs4dkpcf2uytjQTLaq7St7RceXjiv/d9UMuCqBK+tA7aj3Uunz2kouqeczvU4NaOn31ECC3hO1o47R8NfpV3jXGnEASC0E2ACQwSmo0HpEdWi11lXBjzrE6qjG3jpLHXM9TjNCSg1WJzV2OnByKNBQCrKKOmkWTAGnOrwJpZWmhGYrFUSps66AT7NuWgurQNhPi1U7qPCSggqthdVMmjr/CrL91O7E0Iy3OvJ6LgXxCn60/Y/W/fozk/r9FeSqPZXKqoBR6bGaWU2IOv4KdPRzel+UGqvn12y8/q/E7NGstFwFl/pQMKPfUUGTniP8/1HArQBPz+sHqP46Xw1MaLbPnxGOi9LVlcKsINuvAu1Te+o9V6puUgJsBUZK6dVgSXwBsQpXacZas/B+gDtx4sRTKtMr9V1BmQZ6dBxoUCUIynbwMx4UAOr90fui4zt2unc4Bc0KmHVcKNDUGmwN9ijzQrP2ylJQUKv3Te+/X9hMM8o6RhNatqHBGf3/GpxQsK9jSM+nARoNmmg2N6418Qn9/et3U4CswSM9RqnXGtxRUOuvoY+PBroUCOt1q+01IKP3Tb+PnkuDbTo/qKid/7ek403nKaW5q42Scj7T35UGVfT76/9Te+i4i729marVK/hPabV+AEiKLN7pyr8CADI8rU3VrJCq+6qjDwRN6421XlpBTUq3ZUOwMuPfvwb6FJgrDV9p+gCQWliDDQAAUkzFrTSLHN86bSA1KeNBx2PsQm8AEGkE2AAAIMWUDqx0fKUJq5AXkFZ0/KngoWavU7rXOQAkFSniAAAAAAAEgBlsAAAAAAACQIANAAAAAEAACLABAAAAAAgA+2BHyOLFi92+rDly5IjUfwEAAAAAiLBjx465oolVq1Y97WMJsCNEwTVbjAMAAABAxpaUuI4AO0L8meuKFStG6r8AAAAAAETY0qVLE/1Y1mADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsNPQiRMn0vK/T9doGwAAAAAZTfa0fgGZWbZs2ezhB7vaH3+sTeuXkq6ULl3C3h7RJ61fBgAAAAAkCQF2GlNwvXTJirR+GQAAAACAFCJFHAAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAANESYE+bNs1uuOEGq1ixot144432+eefh+77559/rH379latWjW74oorbNCgQXbixIkYP//ee+/Z1VdfbZUqVbK77rrLli9fHuP+IJ4DAAAAAIB0HWBPnz7dunXrZnfffbd99tln1qRJE3vyySdt8eLFduzYMWvbtq173KRJk+zFF1+0//73v/bWW2+Ffv6jjz6yvn37WseOHW3q1Kl2/vnnW5s2bWznzp3u/iCeAwAAAACAdB1ge55nb7zxht1zzz0uwC5evLg9/PDDVrduXVu4cKF98cUXtnHjRhf8li5d2q655hoXfL/77rt29OhR9xzDhg2zVq1aWbNmzaxUqVL2yiuvWJ48eeyDDz5w9wfxHAAAAAAApOsAe+3atfbvv/9a06ZNY9w+atQol9L9008/2aWXXmpnnHFG6L7atWvb/v37bcWKFbZjxw5bt26d1alTJ3R/9uzZrXr16rZo0SL3fRDPAQAAAADA6WS3NA6w5eDBgy6NW+uelZ6tWeyrrrrKNm/ebEWLFo3xM+eee677vGnTJhcIS7FixU55zMqVK93XQTxHSmbo9bvFJUuWLG6WHPE7dOiQa0MAAAAASCuKSRS/pfsAW7PI8swzz9ijjz5qnTt3dindjzzyiI0ZM8YOHz5sBQsWjPEzuXLlcp+PHDniAjDJmTPnKY/R/RLEcySX1n9rljwuCq7Lly+fouePdhqA8d8fAAAAAEgrsePFdBlg58iRw33W7HXz5s3d1+XKlXMz2Qqwc+fOHVon7fOD3rx587r7Ja7H+LPDQTxHSn4/remOS2JHQDKzEiVKMIMNAAAAIE2tXr060Y9N0wC7SJEi7rOKj4VTUPrNN99YzZo17Y8//ohx39atW0M/66d167aSJUvGeIz/3EoPT+lzJJeCaAXxSB5S6AEAAACktaRMjqZpkTMVH8uXL5/99ttvMW5XQKyK4jVq1HCz2X4qucyfP9/9TNmyZa1QoUJulnPBggWh+48fP+4Km+lnJYjnAAAAAAAgXQfYSs9u166d25P6008/tb///tvefvtt++GHH9w+1NpSq3DhwvbEE0+4gmOzZ8+2AQMG2P333x/KgdfXSifXXtaaun/uuefcuuvbbrvN3R/EcwAAAAAAkK5TxEUFzZQKPHDgQNuyZYtL0x4yZIjVqlXL3T9y5Eh76aWX7I477nBbbd11113uZ3y6fd++fTZo0CDbvXu3VahQwQXLZ599dqhYWUqfAwAAAACA08nisQ9SRCxdutR9rlixYoKPu7phC1u6JO5K45lVxUrlbM43k9P6ZQAAAACAJTa2S/MUcQAAAAAAogUBNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYiGonTpxM65eQbtE2AAAAQLCyB/x8QLqSLVtWe/6xt23dn/+m9UtJVy665DzrOeThtH4ZAAAAQFQhwEbUU3C96vf1af0yAAAAAEQ5UsQBAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAIiWAHvLli1WpkyZUz6mTp3q7l+xYoW1atXKqlSpYldddZWNGzcuxs+fPHnSBg8ebPXq1XOPeeCBB2zDhg0xHhPEcwAAAAAAkK4D7JUrV1quXLns+++/t7lz54Y+brjhBtu1a5e1adPGihcvblOmTLEOHTpYv3793Ne+oUOH2sSJE61nz542adIkFyy3a9fOjh496u4P4jkAAAAAAEhIdksH/vjjD7vooovs3HPPPeW+d99913LkyGEvv/yyZc+e3UqWLGnr16+3ESNG2K233uoC4NGjR1vnzp2tYcOG7mcGDhzoZqJnzZplTZo0sffffz/FzwEAAAAAQLqfwV61apULeuPy008/Wc2aNV1g7Ktdu7atW7fOtm/f7ma/Dxw4YHXq1AndX7BgQStfvrwtWrQosOcAAAAAACBDzGCfddZZdvfdd9vatWvtwgsvtIcfftjq169vmzdvttKlS8d4vD/TvWnTJne/FCtW7JTH+PcF8RzJ4XmeHTx4MM77smTJYnny5En2c2cGhw4dcm2YXLRx5NsYAAAAiHae57nYIkME2MePH7c1a9ZYqVKlrGvXrpY/f3777LPP7MEHH7QxY8bY4cOHLWfOnDF+Ruu15ciRIy5AkLges2fPHvd1EM+RHMeOHXPF1eKi4Foz5IifBlv89yY5aOPItzEAAACQGeSMFSum2wBbadsLFiywbNmyWe7cud1tFSpUsD///NNGjRrlbotdaExBseTNmzf0M3qM/7X/GH+GOIjnSA6t+9bAQVwSOwKSmZUoUSLFM9iIbBsDAAAA0W716tWJfmyaB9iSL1++U2675JJLXCXxokWL2tatW2Pc539fpEgRNwPu36Yq4eGP0VZfEsRzJDfAUwCP5CGFPvJoYwAAACC4ibs0L3Kmmepq1aq5Wexwv//+u5v9rVGjhv3888924sSJ0H3z5893M2+FChWysmXLurTy8J/fu3evLV++3P2sBPEcAAAAAACk6wBb1cMvvvhit4WWqn3/9ddf9uqrr9qvv/7qCp1pG639+/dbt27d3NT81KlTbezYsda+fftQLnyrVq3cvtZz5sxxFcE7derkZq0bNWrkHhPEcwAAAAAAkK5TxLNmzWrDhg2z/v372xNPPOFmjlX8SwXO/MrfI0eOtN69e1vz5s2tcOHC1qVLF/e17/HHH3dp3t27d3cFzTTrrPXbWgMtmqVO6XMAAAAAAJCQLB4VjiJi6dKl7nPFihUTfNzVDVvY0iVxVxrPrCpWKmdzvpkc2PO1btzdVv2+PrDniwZlKlxo42f2SuuXAQAAAERNbJcuUsQBAAAAAIgGBNgAAAAAAASAABsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAASAABsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAASAABsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAASAABsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAASAABsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAASAABsAAAAAgAAQYAMAAAAAkF4D7P3790fiaQEAAAAASLeyJ+eHjh49au+++64tXLjQfe15nrtdnw8ePGirV6+23377LejXCgAAAABAdAXYffv2tQkTJljp0qVt586dlitXLjv77LPtjz/+sGPHjtmjjz4a/CsFAAAAACDaUsRnzZplbdq0sY8//thatWplFSpUsA8++MDdft5559nJkyeDf6UAAAAAAERbgK1Z6/r167uvNYu9dOlS93WRIkXswQcftBkzZgT7KgEAAAAAiMYAu0CBAm7ttVx44YW2adOmUGGziy66yH0PAAAAAEBmkqwAu3r16jZ+/Hg7dOiQC7Dz5Mljs2fPdvctXrzY8ufPH/TrBAAAAAAg+gJsFTH79ddfXTp49uzZ7a677rLnn3/ebrnlFnvjjTfsuuuuC/6VAgAAAAAQbVXEy5QpY59//rmrGi5PPfWUm7X+5Zdf7KqrrnKBNwAAAAAAmUmyAmwpXLiw+5AsWbLYQw89FOTrAgAAAAAgOgPsN998026//XZXKVxfJ0QBd4cOHZL8YtauXevSzP10c1mxYoX17t3bfv/9d7fX9n333Wf33HNP6Ge0JZhej7YJ27dvn9WoUcNeeOEFu+CCC0KPCeI5AAAAAAAILMDW1lyRCrCPHTtmnTt3toMHD4Zu27Vrl9tvW2nnL730klv3rc/58uWzW2+91T1m6NChNnHiROvTp48VLVrUXn/9dWvXrp198sknljNnzkCeAwAAAACAwALslStXxvl1UIYMGXJK9fH333/fcuTIYS+//LIrplayZElbv369jRgxwgXH2ips9OjRLjBv2LCh+5mBAwdavXr1bNasWdakSZNAngMAAAAAgIhUEZe///7bPvzww9D3f/31l/Xt29c2btyY5OdatGiRTZ482c0gh/vpp5+sZs2aLjD21a5d29atW2fbt293gf6BAwesTp06ofsLFixo5cuXd88Z1HMAAAAAABCRAFtp1jfffLONGjUqdNvevXvt448/tubNm4eqiyeGfq5Lly7WvXt3K1asWIz7Nm/e7FK2w5177rnu86ZNm9z9Evvn9Bj/viCeAwAAAACAiFQR79+/v1WrVi3GWuyqVavanDlz3B7ZmskeOXJkop7rxRdfdD/btGnTU+47fPjwKWugc+XK5T4fOXLEDh065L6O6zF79uwJ7DmSy/O8GGvKY69Tz5MnT4qeP9rpvVEbJhdtHPk2BgAAAKKd53kutohYgL1s2TJ76623LHfu3KcEpffee6916tQpUc8zbdo0l8KtYmJx0fNrjXQ4BcWSN2/e0P+vx4S/Fj3GD16DeI7kUuE2VTCPi55baehIuKq8PwCSHLRx5NsYAAAAyAxyJrL4dbICbAWiW7ZsifM+Ve3OmjVxmedTpkyxHTt2hIqL+Xr06GEzZsxwqd1bt26NcZ//vaqZHz9+PHRb8eLFYzymTJky7usgniO5VFytVKlScd6X2BGQzKxEiRIpnsFGZNsYAAAAiHarV69O9GOTFWCrwvbgwYOtXLlyMYJQFTpTNXBt55UY/fr1cync4Ro1amSPP/64NWvWzKZPn26TJk2yEydOWLZs2dz98+fPd0FBoUKFrECBAq7y+IIFC0LBsdZ0L1++3Fq1auW+157WKX2OlAR4miVH8pBCH3m0MQAAABDcxF2yAmxtadWyZUtX0Oz888+3s88+281cb9iwwX2vomWJoRnkuCjw1X3aRktrubt16+b2pV6yZImNHTvW7WPtT9MrCFagrtdw3nnnuT2sNWutQF2CeA4AAAAAACISYBcuXNitm546dar98ssvtnv3bhcQK1C95ZZbLF++fBYEBdoKjnv37u2Cef2/Ct71tU+z3UrzVhVyzYZrxlrVzZWeHdRzAAAAAABwOlk8FmBGxNKlS93nihUrJvi4qxu2sKVL4i6ElllVrFTO5nwzObDna924u636fX1gzxcNylS40MbP7JXWLwMAAACImtgu2TPYfvXhb7/91m1DdfLkyVNy1Dt06JDcpwYAAAAAIMNJVoCt4mNdu3aNt/owATYAAAAAILNJVoA9dOhQq1u3rvXq1csVA2M7JAAAAABAZpe4Datj2bhxo6vIXaxYMYJrAAAAAACSG2BrD+lNmzbRgAAAAAAApCTAfuqpp1ya+IIFC+zIkSPJeQoAAAAAAKJKstZga0/pHTt22H333Rfn/VqTvXz58pS+NgAAAAAAojvAbtasWfCvBAAAAACAzBZgP/roo8G/EgAAAAAAMluALVp7vWrVKjt69GhoP+yTJ0/aoUOH7KeffrLOnTsH+ToBAAAAAIi+AFvFzTp27Gh79uyJ8/58+fIRYAMAAAAAMpVkBdgDBw60s846y3r27Gkff/yxZc2a1W655Rb77rvv7L///a+98847wb9SAAAAAACiLcBWanivXr3s2muvtX379tmkSZOsQYMG7uPYsWP29ttv24gRI4J/tQAAAAAARNM+2FprXaRIEff1hRdeaH/++Wfovuuuu44tugAAAAAAmU6yAuzixYu7WWwpUaKEK2y2Zs0a9/3x48ftwIEDwb5KAAAAAACiMcBu2rSp9evXzyZMmGBnn322VahQwa3H/uqrr+ytt96yUqVKBf9KAQAAAACItgC7Xbt21rJlS/vtt9/c9z169LAVK1bYI4884mayu3TpEvTrBAAAAAAg+oqcqWr4M888E/q+YsWKNnv2bBdcX3zxxZY/f/4gXyMAAAAAANE5g92hQwf78ssvXcVwn4LqSpUqEVwDAAAAADKlZM1g//PPP/bYY4/ZGWecYY0bN7abbrrJqlWrFvyrAwAAAAAgmgPs6dOn219//WWffvqpzZgxwyZPnmznn3++NWvWzAXb2roLAAAAAIDMJFkp4lKyZEnr2LGjffHFF/bBBx/Ytddea9OmTXMz2i1atAj2VQIAAAAAEK0Bdux9sRVwlylTxhVA+/vvv4N4WgAAAAAAojtFXA4ePOgqhytF/IcffnCBdYMGDWzw4MHuMwAAAAAAmUmyAmylhn/33Xd2+PBhV9zs+eeft+uvv94KFCgQ/CsEAAAAACBaA+xVq1bZAw884IqaqbgZAAAAAACZXbIC7JkzZ8b4/siRI5YzZ07LkiVLUK8LAAAAAIDMsQZ7zZo1br31vHnzbP/+/a6S+IcffmgXX3yxtW7dOthXCQAAAABAOpesKuIrVqyw2267zZYtW2ZNmzY1z/Pc7dmyZbNXXnnFPvroo6BfJwAAAAAA0TeD/dprr1mFChVs9OjR7vv33nvPfe7evbtLFx83bpw1b9482FcKAAAAAEC0zWD/+uuvdt9991n27NlPWXd9ww032Lp164J6fQAAAAAARG+AnStXLrdFV1x2797tCp4BAAAAAJCZJCvAvvzyy12Bs82bN4du00z2gQMHXNp43bp1g3yNAAAAAABE5xrsp59+2lq0aGGNGze2smXLuuC6T58+tnbtWlfwbMCAAcG/UgAAAAAAom0Gu1ixYjZ9+nS79957XUBdvHhxO3jwoDVp0sSmTp1qF1xwQfCvFAAAAACAaNwH+6yzzrJOnToF+2oAAAAAAIj2AHvatGlJeuKbb745Oa8HAAAAAIDoDrC7du2a6CfVmmwCbAAAAABAZpLoAHvOnDmRfSUAAAAAAGSGAPu8886L8/Z9+/bZ1q1bXWGzbNmyuQ8AAAAAADKbZFURlwULFtjtt99uNWvWtKZNm9qff/5pTz31lNuuCwAAAACAzCZZAfaPP/5obdu2tdy5c1vnzp3dVl2iPbHHjRtnY8aMCfp1AgAAAAAQfQH2oEGD7Oqrr7bx48eH9sKWhx56yNq1a2cffPBB0K8TAAAAAIDoC7BXrFhht956a6hieLjLL7/c/v3332BeHQAAAAAA0RxgFyhQwLZt2xbnfZs2bXL3AwAAAACQmSQrwFZ6+MCBA23p0qWh2zSTvXnzZhs2bJg1bNgwyNcIAAAAAED0bNMVTtXCf/vtN7vjjjvsnHPOcbc9+eSTLsAuVqyY+xoAAAAAgMwkWQH2GWec4QqZTZs2zebPn2+7d+92aeGtW7e2W265xfLkyRP8KwUAAAAAINoCbMmZM6ebwdZHbKtWrbIyZcqk9LUBAAAAABCdAfaOHTts1qxZbr31VVddZeeee26M+/fu3eu28Hr//fft999/D/q1AgAAAACQ8QPsJUuWWNu2bW3fvn3u+wEDBti4ceOsbNmy7nuljOu2Xbt2WaVKlSL3igEAAAAAyMhVxN944w23tvqdd96xSZMm2XnnnWevv/66HTp0yNq3b28vvPCCZcuWzXr37u1msAEAAAAAyEwSPYO9bNky69ixo9WrV899//zzz9t9993nKop/9913dtddd1mnTp0sf/78kXy9AAAAAABk7ABbqeGXXHJJ6Hulhh89etR+/vlnGzNmjNWuXTtSrxEAAAAAgOhJET9x4oSrHO7LlSuX+9y5c2eCawAAAABAppfoADs+5cqVS3Ejqjr5008/7QL1qlWr2oMPPmh//fVX6P4VK1ZYq1atrEqVKq56uYqrhTt58qQNHjzYpa/rMQ888IBt2LAhxmOCeA4AAAAAACIWYGvLrpTq0KGDrV+/3kaMGGEffvih5c6d263vVgE1VSVv06aNFS9e3KZMmeIe269fP/e1b+jQoTZx4kTr2bOnK8CmYLldu3YuhV2CeA4AAAAAAALbB1vBrwqaied5LriePHnyKfth63YFsYmxZ88eV5FclchLly7tbnvkkUfspptusj///NN+/PFHy5Ejh7388suWPXt2K1myZCgYv/XWW10APHr0aJeq3rBhQ/fzAwcOdDPR2rO7SZMmrqp5Sp8DAAAAAIDAAuy4tt+K67akBNhnnHGG9e/fP/T9zp07bezYsVa0aFErVaqUDRkyxGrWrOkCY59SyYcPH27bt2+3jRs32oEDB6xOnTqh+wsWLGjly5e3RYsWueD4p59+SvFzAAAAAAAQSIC9cuVKizRt/aWAXcXU3n77bcubN69t3rw5NLPt82fMN23a5O6XYsWKnfIY/74gngMAAAAAgMBmsJNK65ivvfZaGzZsWIwtvuJz7733WosWLey9995zM+BaE3348OEY1cvDK5gfOXLErdOWuB6j9HMJ4jmSQ2n0Bw8ejPM+zfLnyZMn2c+dGeh9URsmF20c+TYGAAAAop33v+XRaR5g64X8+++/iS4UppRw6d27t/322282YcIEV/As9s8rKBbNcOt+0WP8r/3H+AFsEM+RHMeOHXPVy+Oi51UKOuK3du3a0OBHctDGkW9jAAAAIDPIGWsyNk0C7MTQmmsVMrvuuutCa6SzZs3qgu2tW7e6tdj6HM7/vkiRInb8+PHQbaoSHv6YMmXKuK+DeI7kUGE1f9AgEtXXo12JEiVSPIONyLYxAAAAEO1Wr16d6MemeYCtImNPPvmkjRw50lXt9md+ly9f7varPuecc9y2WSdOnLBs2bK5++fPn+8Cg0KFClmBAgUsf/78tmDBglBwvHfvXvfz2vdaatSokeLnSG6ApxlyJA8p9JFHGwMAAADBTdyleB/slFLxsfr161uvXr1cxe4//vjDunbt6gJc7YWtbbT2799v3bp1cyMHU6dOdVXGta2XP1WvIFj7Ws+ZM8cVY+vUqZObtW7UqJF7TBDPAQAAAABAup7BlgEDBrituhTU7tu3z6pXr+4Knf3nP/9x92t2W+uymzdvboULF7YuXbq4r32PP/64S/Pu3r27K2imGetRo0a5FG3RLHVKnwMAAAAAgIRk8SK4AFMp2ZdeeqlNmTLFfc5Mli5d6j5XrFgxwcdd3bCFLV0SdyG0zKpipXI255vJgT1f68bdbdXv6wN7vmhQpsKFNn5mr7R+GQAAAEDUxHbpIkUcAAAAAIBoQIANAAAAAEB6D7BVbU1rmfPlyxfJ/wYAAAAAgIxb5Ozo0aP24Ycf2rx582zbtm32yiuv2MKFC91a60qVKoX2sx4/fnyQrxcAAAAAgOiZwd65c6fb+kpVudevX29Llixxlbe/+eYba926tS1evDj4VwoAAAAAQLQF2H379rUDBw7YjBkz7KOPPjK/EPngwYNdZTV9BgAAAAAgM0lWgP31119bx44d7cILL3TrrH25cuWy+++/35YtWxbkawQAAAAAIDoD7CNHjtiZZ54Z533ZsmWzY8eOpfR1AQAAAAAQ/QG20sAnTpwY532ffPKJVahQIaWvCwAAAACA6K8irvTw++67z2666SZr0KCBSxP/9NNPbciQITZ37lwbOXJk8K8UAAAAAIBom8GuXr26jRkzxvLkyeOCaRU5Gzt2rNuua/jw4Va7du3gXykAAAAAANE2g/3jjz9a1apVbdKkSW57rj179lj+/PktX758wb9CAAAAAACidQb7scces1mzZrmvc+fObUWKFCG4BgAAAABkaskKsAsWLOgCawAAAAAAkIIU8fbt21uvXr1s7dq1VrZsWcubN+8pj6lRo0ZynhoAAAAAgMwTYPfo0cN9HjhwoPusKuI+FTzT9ytWrAjqNQIAAAAAEJ0B9rhx44J/JQAAAAAAZLYAu2bNmsG/EgAAAAAAMluALVp/PXjwYFu4cKHt3bvXzjrrLLc/docOHaxkyZLBvkoAAAAAAKIxwF69erW1bNnSsmXLZldddZWdc845tm3bNvv666/tm2++sQ8++IAgGwAAAACQqSQrwO7Xr5+df/75Nn78eCtQoEDo9n379tm9997rip+9+eabQb5OAAAAAACibx/sRYsW2UMPPRQjuBZ9/+CDD7r7AQAAAADITJIVYGfPnt1y5coV5305c+a0o0ePpvR1AQAAAAAQ/QF2xYoVbeLEiW7P63D6/r333rMKFSoE9foAAAAAAIjeNdgdO3a0O++805o1a2aNGze2woULuyJnM2fOdNXFx4wZE/wrBQAAAAAg2gJszWCPHDnS+vfv74qZaeY6S5Ysbub6nXfesRo1agT/SgEAAAAAiMZ9sGvXrm2TJk1y6621D3bBggXt+PHjpxQ+AwAAAAAgM0jWGuxjx45Zjx497I477rA8efJYkSJFbPHixVanTh177bXX7OTJk8G/UgAAAAAAoi3AHjJkiH388cd24403hm4rX768de7c2d5//32XPg4AAAAAQGaSrBTxTz75xJ555hlr2bJl6LYzzzzT7rvvPreF17hx49x+2AAAAAAAZBbJmsHetWuXXXDBBXHed/HFF9vmzZtT+roAAAAAAIj+AFtB9BdffBHnfV999ZVdeOGFKX1dAAAAAABEf4r4PffcY127drXdu3fbNddcY4UKFbKdO3fa119/bZ9//rm9+uqrwb9SAAAAAACiLcC++eab7cCBAzZ06FCbNWtW6PazzjrLnn/+eXc/AAAAAACZSbL3wb777rvtrrvusrVr17qZbG3Ndckll9gZZ5wR7CsEAAAAACDa1mAvWbLEHnroIZs2bZr7PkuWLDZv3jxr06aNtW7d2ho0aGCjRo2K1GsFAAAAACDjB9grV650QfSKFSssb9687ralS5da7969XUVx7Y39yCOP2MCBA2327NmRfM0AAAAAAGTcFPHhw4db2bJlbezYsZYnTx53m/a7ln79+rn7ZPv27TZ+/HhX/AwAAAAAgMwi0TPYixYtcjPYfnAtc+fOdbPXfnAtV1xxhS1fvjz4VwoAAAAAQDQE2CpkVrRo0dD3f/31l+3atctq1aoV43EKwI8ePRrsqwQAAAAAIFoC7DPPPNN27NgR+n7+/PmuyFmdOnViPE6B99lnnx3sqwQAAAAAIFoC7Jo1a9r7779vnufZ8ePHbcqUKZYrVy6rV69e6DGauX7vvfesWrVqkXq9AAAAAABk7CJnDz/8sLVo0cIVL1OQvXHjRuvQoYMVKFDA3a+AW8G19sXu27dvJF8zAAAAAAAZN8C+5JJL3Az26NGjXar4Aw88YHfeeWfo/kGDBln27NntrbfesnLlykXq9QIAAAAAkLEDbClVqpS98sorcd734YcfWuHChS1r1kRnnQMAAAAAkDkD7IQUKVIkqKcCAAAAACDDYboZAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIBoCLB3795tL7zwgtWvX9+qVatmd955p/3000+h+3/88Ue75ZZbrHLlyta4cWP77LPPYvz8kSNH7KWXXrI6depY1apV7amnnrKdO3fGeEwQzwEAAAAAQLoOsJ988klbvHixDRgwwKZMmWLlypWztm3b2po1a+yvv/6y9u3bW7169Wzq1Kl2++23W5cuXVzA7HvxxRdt7ty5NmTIEHv33Xfdzz3++OOh+4N4DgAAAAAATie7paH169fbDz/8YBMnTrTLLrvM3fb888/b999/b5988ont2LHDypQpY506dXL3lSxZ0pYvX24jR450s81btmyxadOm2bBhw6x69eruMQrUNUutoF2z0QqYU/ocAAAAAACk6xnss846y0aMGGEVK1YM3ZYlSxb3sXfvXpcqriA4XO3ate3nn382z/PcZ/82X4kSJaxIkSK2aNEi930QzwEAAAAAQLoOsAsWLGgNGjSwnDlzhm774osv3My2Uro3b95sRYsWjfEz5557rh06dMh27drlZp8VpOfKleuUx+hnJYjnAAAAAAAgXaeIx/bLL7/Ys88+a40aNbKGDRva4cOHYwTf4n9/9OhRFyTHvl8ULKtwmQTxHMmlGfKDBw/GeZ9m6fPkyZOi5492em/UhslFG0e+jQEAAIBo53meiy0yVIA9e/Zs69y5s6sk3q9fv1CQqyA4nP+9gtPcuXOfcr8oMPaD1yCeI7mOHTtmK1asiPM+PXf58uVT9PzRbu3atS4ATC7aOPJtDAAAAGQGOeOYlE23AfaECROsd+/errDYa6+9FnrxxYoVs61bt8Z4rL7PmzevFShQwKV+a5svBcjhv7AeozXUQT1HcuXIkcNKlSoV532JHQHJzLQWPqUz2IhsGwMAAADRbvXq1Yl+bJoH2Kog3rNnT2vdurV169YtRlCkqt4LFy6M8fj58+e7We6sWbO6yuMnT550hcr8QmaakdO66ho1agT2HMml30WBPJKHFPrIo40BAACA4Cbu0rTImQLZV155xa699lq3V/X27dtt27Zt7mPfvn0u6F6yZIlLGdd+1qNHj7aZM2dau3bt3M9rhvnGG2+07t2724IFC9xjta92zZo1rUqVKu4xQTwHAAAAAADpegZbFcO1TvnLL790H+GaN29uffr0saFDh9rrr7/u9rM+//zz3dfh225p9ltB+qOPPuq+r1+/vguWfZdcckmKnwMAAAAAgNPJ4rEAMyKWLl3qPofv8R2Xqxu2sKVL4i6ElllVrFTO5nwzObDna924u636fX1gzxcNylS40MbP7JXWLwMAAACImtguzVPEAQAAAACIFgTYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AAAAAQAAIsAEAAAAAiMYAe/jw4da6desYt61YscJatWplVapUsauuusrGjRsX4/6TJ0/a4MGDrV69eu4xDzzwgG3YsCHw5wAAAAAAIEME2O+9954NGjQoxm27du2yNm3aWPHixW3KlCnWoUMH69evn/vaN3ToUJs4caL17NnTJk2a5ILldu3a2dGjRwN7DgAAAAAAEpLd0oEtW7ZYjx49bMGCBXbRRRfFuO/999+3HDly2Msvv2zZs2e3kiVL2vr1623EiBF26623ugB49OjR1rlzZ2vYsKH7mYEDB7qZ6FmzZlmTJk0CeQ4AAAAAANL9DPayZctcAPzxxx9b5cqVY9z3008/Wc2aNV1g7Ktdu7atW7fOtm/fbitXrrQDBw5YnTp1QvcXLFjQypcvb4sWLQrsOQAAAAAASPcz2FoTrY+4bN682UqXLh3jtnPPPdd93rRpk7tfihUrdspj/PuCeA4AAAAAANJ9gJ2Qw4cPW86cOWPclitXLvf5yJEjdujQIfd1XI/Zs2dPYM+RHJ7n2cGDB+O8L0uWLJYnT55kP3dmoPdFbZhctHHk2xgAAACIdp7nudgiKgLs3Llzn1JoTEGx5M2b190veoz/tf8YP4AN4jmS49ixY656eVz0vEpBR/zWrl0bGvxIDto48m0MAAAAZAY5Y03GZtgAu2jRorZ169YYt/nfFylSxI4fPx66TVXCwx9TpkyZwJ4jObSuvFSpUnHel9gRkMysRIkSKZ7BRmTbGAAAAIh2q1evTvRj032AXaNGDbdt1okTJyxbtmzutvnz57vAoFChQlagQAHLnz+/q0DuB8d79+615cuXu32vg3qO5AZ4miFH8pBCH3m0MQAAABDcxF26qCKeEG2jtX//fuvWrZsbOZg6daqNHTvW2rdvH5qqVxCsfa3nzJnjKoJ36tTJzVo3atQosOcAAAAAACBDz2BrhnnkyJHWu3dva968uRUuXNi6dOnivvY9/vjjLs27e/furqCZZqxHjRrlUrSDeg4AAAAAABKSxWMBZkQsXbrUfa5YsWKCj7u6YQtbuiTuQmiZVcVK5WzON5MDe77Wjbvbqt/XB/Z80aBMhQtt/Mxeaf0yAAAAgKiJ7TJEijgAAAAAABkBATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2ABS5OSJk7QgbQMAAAAzy04rAEiJrNmy2uBOE+zfv7bQkGHOK1nEHh/YijYBAADIRAiwAaSYguu1y/6lJQEAAJCpkSIOAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYApHMnT5xM65eQbtE2AAAgPcme1i8AAJCwrNmy2nvP/de2rt1KU4U5t8S5dvcrd9ImAAAg3SDABoAMQMH1vys3pvXLAAAAQAJIEQcAAAAAIAAE2AAAAAAABIAAGwCQqVEojbYBACAorMEGAFhmLyL3Za/Jtmv9trR+KenKWRcWtmu7t0jrlwEAQIZCgA0AyPQUXG//kyJyAAAgZUgRBwAAAAAgAATYAAAAAAAEgAAbAAAAAIAAEGADAAAAABAAAmwAAAAAAAJAgA0AACLKO3mSFqZtACBTYJsuAAAQUVmyZrXfBkyyA/9spaXD5Dv/XKv8ZEvaBACiCAE2AACIOAXXe9ew1zgAILqRIg4AAAAAQAAIsAEAAAAACAABNgAAAAAAASDABgAAyOCo1B75tqGNaRsgMShyBgAAEAWV2v8dPcGObtqS1i8lXclZrIidd3+rwNp416cT7PgO2jhc9kJF7KwmwbQxEA0IsAEAAKKAguvDG/5N65cR1RRcH99CGwOIHyniAAAAAAAEgAA7zMmTJ23w4MFWr149q1Klij3wwAO2YcOGINoZAAAAQDw8L5i18tEoqLahjVOnbUgRDzN06FCbOHGi9enTx4oWLWqvv/66tWvXzj755BPLmTNnYI0OAAAA4P/LkiWr7V80zU7s20GzhMlWoJDlr3FzYG188O+5dvLIHto4TNZcZ1je4ldYUAiw/+fo0aM2evRo69y5szVs2NDdNnDgQDebPWvWLGvSpElgjQ4AAAAgJgXXJ3ZvplkiSMH1yUM7aeMIIkX8f1auXGkHDhywOnXqhBqnYMGCVr58eVu0aFEk3wMAAAAAQBQgwP6fzZv/b7SsWLFiMRro3HPPDd0HAAAAAEB8snie58V7byYyffp069Kli61YscKyZv3/4w66bevWrTZ27NgkPd8vv/xiatocOXLE+5gsWbLY9u077dix4yl67dEmR47sds45Z7v2Sym18a4de+34sROBvLZokT1HNjurUMHA2njvjv12/DhtHKONs2ezgoXyB9bG+3fttxPHKAATLluOrJb/rJS3sdr30O4DdpJjOIas2bNZnjPzBXYMH91zwDzaOGa7ZM9mOc8Iro1P7Ntv3gnOxTHaJVs2y1YguHPxyYP7zTtJG8dol6zZLGveYM7F3pGD5nm0b8x2yWZZcuUN7Bj2jh82o6BcTFmyWpbsuRNs42PHjrn2q1atmp0Oa7D/J3fu3KG12P7XcuTIEcuTJ48lld6A8M/xUSCJhNswpRRIIrJtrEASkW1jBZKIXBsrkETk2lcUSCKybaxAEpFtYwWSiFwbK5AM5p2KPkEdwwokkfQ21n2JfQ8IsP/HTw3XbHXx4sVDDaTvy5QpY0lVtWrVJP8MAAAAACDjYg32/5QtW9by589vCxYsCDXO3r17bfny5VajRo20en8AAAAAABkEM9j/o32uW7VqZf369bOzzz7bzjvvPLcPtvbDbtSoUdq+SwAAAACAdI8AO8zjjz9ux48ft+7du9vhw4fdzPWoUaMSLFQGAAAAAIBQRRwAAAAAgACwBhsAAAAAgAAQYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAARcPLkSdoVADIZAmwASCY6z5FHG0eW53kR/h8ypxkzZrjPWbPSzULGPvdyDo6Mf//9N0LPjPQge1q/AAAp99lnn9lff/1le/futTvvvNOKFy9uOXLkoGkDNnPmTFu3bp0dOnTItXPRokVd54NONG2c0YLqLFmyuK/1+cSJE5YtW7a0fllR45VXXrH33nvPLrvsMitSpEhav5yos2fPHjt69KgVLlw4zmMaKffBBx/Y/Pnz7dVXX7WcOXNynQvYlClTXBs//vjjVrdu3aCfHukAATZSBUFI5PTt29c++ugjK1SokG3cuNHmzJljr7/+ulWvXp1OR4D69etn06ZNs1y5ctnu3btt0qRJ7iJ5/vnn0860cYahTt3cuXNdUF2zZk275557XHBNgBJccK3zhM4NBNfBGzlypM2ePdtWr15tV199td1+++3uWkdwHZzjx4+7AfsVK1a44/m5554jyA7YGWecYUeOHLF3333XHbt16tQJ+r9AGsvikR+GCPrxxx+tTJkydvbZZ9OBiwBd/BRcv/POO3bBBRe4Nm7Tpo3r2KkjgmA7zW+99ZZdeOGFtmHDBuvWrZuVLl3aBg0a5C6QdPBo4/Tutddes+nTp1ulSpXcYNwff/xhjz76qPtAMOeJqVOn2oQJE6xs2bIuUMmenXmMoGg29eOPP7abbrrJff/+++9bjRo13HmZdg7WwYMHbfTo0fbFF19Y1apVrXv37gTZAfvuu+9s8ODBduaZZ1rbtm0JsqMMZ35ENLh++umn7frrr7dHHnnEzjrrLILsAPXu3dsF135nzqdZqbVr1wb5X2VqcbXzOeec44LrY8eOhdLDmQGkjTPCYJwG3ipXrmw7duxwAfeXX35pd911lzs/M0iUsuBPS3XGjRt3SnC9bNkyu/TSSwN7LzPz8av2LVeuXOhap76FZlorVqyY1i8xqjIO8+bNa/fff7/LdFHGQK9evQiyA+L3FerXr+++HjJkiI0aNcrdx0x2MD7//HN3nfvPf/5jaYXqG4gYnShuvPFGW7hwoQ0fPtx27drlTioJJU2QUJE4AwYMcJ0Njeb7nbnwNtTaYKTcG2+84VJqY7ezgmqt/ws/efvBiTokoI3T2yCRMjCUjqhOh45jLSlR0KfjVZ1pguuUDSarbR944AErX768Wx/sB9dDhw61Vq1a2ebNmwN7PzObPn36uOvd+PHjXXDtn4fPPfdcu+SSS9wMoHDuDYaub36QrWP6mmuuscWLF7sgW8e27qevljTh7RXeD27QoIE99thjbtmZgmydS5AyW7ZssU6dOlmPHj3c12mFABsR9eyzz7pAW2v+Egqyt23b5ioq0sk7vfXr17u0LaXd+wGe324qrDNx4kTbunWrWzOs1Dl1rLdv304HL4k06/Thhx9ahQoVrGDBgu42vxCU2lhtrXZVB1op+vPmzbP9+/e7QnOgjdMLHZ8KTFQzIHbwt2/fPncOyZ07d5yVgulEJ44CvZtvvtmdczXbp6JQMmLECJf5ooE6Bj2TZ+zYse5D51wNcipryD9+f/nlF1dwUudlHdeIbJD966+/uqwXvQf01ZLGby//nBpfkK2BuqVLl3IoJ5PaVEskdb1TH05BdloNbrIGG4Fas2aNO5g1wqwq1n66iwpxab3JFVdcYe3bt3fpiOHB9fPPP2+//fabffPNN65zwsk7fupIaJTz5ZdfdoUytOZP3n77bRfoqROiE4xOLgq0dTHUyL5u/+9//2t58uThqE8kXeyU9qmUcJ2o1a4aKNKH1rxfdNFFtmjRItfJ04fUqlXLvRfqmOD0lPL56aef0sYRsHPnTmvXrp07BzzxxBOuKFR4uyvt9uKLL7ZSpUq580rt2rXdMX3eeee5WgN+oIjT++eff+zNN990A5rq3K1atcplGinorlevHk2YDOpH6Pr24osv2oMPPugqLvtLcsaMGeOCPRWdLFmypKuLod0z1MfIly+fK34W3s9A3JRer6rs+rjyyitP+Zv3C9QeOHDALS/59ttvXR/uuuuuo0kTQZNLmhRRP1fnV32EC19a9v3337tsoyZNmlAXIwAaENKxqhoCOof4g5zhba6lUj///LNL19dAc5AIsBHoTMnXX3/tZvV0Mtb6KHUw/BO2LoZ+kK11UwoOlb6h4FsnbV0wWUeVtCD7pZdeckGfLoxqP7WlAjy1uYJqDXaomNGCBQvcBVHpdEgaBSLqNJcoUcLN9mlWW8eyjm+dkHWCVjVQncw1wEQ7Jx1tHNkOtHYVUNGi1q1bu2U7SkXUIJFmpTT7unLlSneuUFCozocCbBWQUho5Eha+xZmCPK2n/OSTT1xQokriGtikPkPShLeXBi41yKkOso7fZ555xmUG6Bi+77773DVN2W9qexXt08Cy3hO9BxoERfx0rGrXEV3DFACqFoOKmcXedtI/xpWhpYGLhg0buvcBCVP/VzUuNKmhNlaAp35aQoPv6tPpnK2sI7ZaTTwFyToP6BpWpUoVN5BRoEABN3GnwbnYQbZoAkqDzLr+qb3Dt/0LAgE2AqFReo00a1ZVQbICDqXVam3UkiVLXNVaUWCiUToF2bfeequrUqliBJpZ9QuX4FQ6SWsUVJ2Oyy+/3HXa1MYKnNV5/vPPP93stWZKFHz7ATZ72yaNBoD+/vtvl36vgNo/JhUAqrOsDpyO4WbNmoXal85zMFkuSqXVenfaOHgKOnTcioJmLWdQ9VoNxoXzZ1o0aEdwEj9d07Q9n84TsbehVBuqs6bj2T8nh6eF4vQ0GCR+IHL48GEXMCuLSHUD1JHWdU/XwnA6JyuQEQ0cIX79+/d351t9VoaWjk21t47rcOpnKAMmf/787nutbVWmgDJiOKbjp2UhymTRIIZ20tGxqfNA7KwK9de05ZyW74jWuWsppb//OE5PO7ko+9Vf9qTsKw3A+edb1Q/QTHa1atVCk1KaCFQba0mPlp9EogglATZSTLN7mr1WkO0H0j4d5LoQaq9V7aUo6ugpbUZrVZWWpIPbP7ngVGovrbnWyJvaTJ0LjYJqlE4nZ3WWdaLQgIYumML2MEmn41SDPRrFVBtrFq9jx45Wt25dd7/WXGv2WoGHtujSSZpBjGCzXNTGOobVgaONk2f+/PkuXVn72OoYve2221znWKP0Ok9oRF9Ftzp37hzjXMFAUeLoGO3Zs6ebxVMQp7WTSkkOn5Vat26dDRs2zF0btVxEGUbhQTjip0F39Q/UN9A5WP0KnR8UZM+YMcNdDy+77DJ3LvH552HaOHHUvjqG1ZbqR4TTAKfOzX6NF80Mqu+mtGUFfrpGTp482aXlI26a8NAMv86xfv/Bp8zDTZs2uckn1XfRYJIG7JWJob6H2lsDdOE7wyB+AwcOdNlWCrK11EkDyDpONZDx1VdfuX6z4ovwIFvnbJ1nlL0R0ck97YMNJMfJkyfd5x49engDBgzwTpw44T58b7/9tle3bl3v5Zdf9ipXruz17NkzdJ9uu/rqq72VK1fS+Ano3bu3V716de+3337zjh075v3111/eQw895D355JPuezly5Ij33XffeQ0aNPBuueWW0M/69+P0evXq5dWoUcP7+eef3feLFi3y7r77bu+NN96I8bhx48Z5zZs39zp06OBt3rzZ3RZ+zCN+r7/+ulenTh3vyy+/dG23fv16b9euXe6+JUuW0MYB0Hn4hhtucMduo0aNvMcee8ydH3zLli3zWrdu7d11113eJ598csq5HKf33nvveWXKlPGee+45r2nTpu78rHaeP3++t2/fvtDjdHw//fTT3qWXXurNnDmTpk2EV155xatdu7Y3duxYb/Dgwd6VV17p3XnnnaH7Dx486H3wwQde+fLlvVdffZU2Tab333/fa9++fYy/e/UxXnrpJa9cuXLu+L722mu9oUOHev/884+73rVq1cpr166dt2LFCtr9NObOneuO3W3btrnv1c7z5s3znnrqKde2/kfHjh29VatWuWviM88847322mven3/+Sfsm0qxZs7zGjRuH+m3Hjx8P3Td69Gh3nmjZsqW3dOlSd9svv/ziXX755a7tL7vsMm/58uVeJBFgI0V2797tXXHFFe5gDvfFF1+4A1gnGvnwww+9smXLeqNGjQo9ZseOHbR+Avr27euCvtWrV8e4/c033/Tuu+8+7++//3YnDr8D/f3333vXXHONuzAi8fr16+c6yf6Fze909OnTxwUq6ij/+uuvocePHz/eu/322717773X27JlC02dCB999JE7LtWJi23kyJHugqfBpPCBDNo46cF1rVq13ODQ/v37Q+dnUTDtDwhpMENBtjoen332GcdvEh09etRr27at6yyrTXXcqjOt65vOCQoODx8+7B67d+9e75FHHvFq1qzp3hMGMhIe5FSfIXyw7ccff/Suuuoq748//ojx2EmTJrnOswISJJ3OuRqQ37lzpzsmNZihvoMmQjR4r/6aPjdp0sTbvn27+xkd0+GDdTiV//et65wGONWOOgdrckmBXdWqVd15esGCBd63337rvv/8889DP8v5IXH8dtKgfefOnd3AW7jhw4e7a6H6djona0D5999/d/cpGL/pppsiHlwLATZSREGyZqInTpwYY9ZUnbzwA1gnGQWL4Z1oxE8dYgUdCqZ9/uicRvkrVKjgLpB6zKOPPuqCbd0/e/ZsN6ui75G4kXy14dSpU0O3+TPSyszQRbFevXpexYoVva5du8Y4gWtEf9OmTTRzhLJcRowYQRsn0tdff+3deOON7rzrB4G+MWPGuGNcHY6NGze62xTEtGnTxv0Ms6tJo/OsOnYK/JRRJPqsmVV/ZkqBiWZYNdu3du1aBuJOY8iQIS5g9s+nfiCnGUBd54YNG+YyBjQg5Ad8/rl74MCBSXwHMy//fKwgo1mzZu7cq4wBzVrr+59++ik0OKfztAaeP/744zR+1RmPBt4026/20zGqLBYN1itjM/z6pz5E//790/S1ZkQnTpxwsYb6ujp3hB/b6gNroE6Dc/4s93XXXef6b36GUWoNFBFgI8WUHqfUZD/dM5x/0H/zzTfe9ddf71I0cHpKG9LJVx9TpkwJ3a6ORpUqVVxAqM6bOhw6gb/77rvufp10Dhw4QBMnko5ZdeA0W6pR5fAAulKlSm4EWiPNSgtVJ8Rv5/DZQQSb5RL+ONo4Yf75VZ2MJ554wjt06FCM+5XiqdlTZQSog6cUfT/I1iyLlpts2LCBQziR/EFOzfwpMHn22WdD93Xv3t0F3Tp+ldas87JmtjWLjfhpAEIDPeosx06P1XlY7Xj//fe7TrICFX+gTp1kZcbEzvDCqf79918X9G3dujV0mwbWNOGhGUC1o3+u1TlFx7naVf0PlvGdnpbe6Dqm49cP4pT5pjZ+55133ICGf7s/CaXJKQ1ykkWUfPfcc4+LP8JTw9W+6j+Ha9iwoUvBT20E2EjWidpfWyITJkxwI6G6GMY3QvTiiy+6VA11TJA4urApFbxFixZugELp9eos6+twt9566yknGSSejkl1hJU2tGbNGnccq50VWIcH4lrbqlkUJA1ZLpGlYEMdYa2fFP88oDV/Ckp++OGHUCdQaYtKDfdT6kj5TPr1zm8zzTzpuqdOtWZHlO0Svj5VnWr9PE5vxowZrrOsgQl/GYnOw5oBVHaGP3DUqVMn18579uyhWRNJg2933HGHy2DRINvkyZMTfLw/w6olajfffHOMYx/x171Q+2oZlJaOxLX8MXb6t35O2Z+cI5JOQbSO0xdeeMFd09atW+duj90H1mN0PtEAnt9vTs00/OyRKZ2GaPTmm2+6Lba0DYmq9d10001uT8S7777bVaVU1VRVtdb3/lYEqhasiojaYkPVwmNvUYD/b/ny5a76oSrTFitWzG3toEqUqvSp7c/Ultr/U1vr+JV/tX2G9lgsXbo0W3IlkqoraysHVQNX2+mYVHVwbRunistqV1Wu1fY6fjurSrAeF3sLE5yeqtGqiqfa+Prrr3fVU6V69erus1+9WvuIa7sYPQaJp8rU2o9d52Xxt+bT+UPn5Isuush9r/cgV65c7v3QcS9sA5P4613z5s3dOcJvs/r169vYsWNdRXbtt6qq1qr861e0VrVaJI7+5nUeUEVfVQXWLgKzZs1yOwz452HRtlxLly51Va61awYSpl0Dpk+f7vb6Vd/il19+sXfffddtSRS+LdHChQvdDiXaK1g7aPiVwlUxX+dkxE3tqvZVBWsds2o37dmuSuDXXntt6HHqH+u49bdXVSVxVcTXe6FK7Uhav027Yqhfpv2t1Y7acjKubc10bdT9ut75OxWl5laJBNhI9olanQt14rQ1l7YiUel7XSC1H/YNN9zg9rtVR0OfFWQrCETc1KnQfnzaw1MdB7WptsbQCVnbFandtQ2Mv8enTi6iDrTaV1tuIHF7U+oiuH//fjc4oe3jWrRo4ToR2lJHg0M6iZ9xxhmuo+y3szrP6mjrfUDCNm7c6P7u9eF3zjQopDbUdhp33XWXu0D6+7X7FzztY6nBJT8gROIp8NA5Vh03f19xBdL+Ps0KXrRNl/Ydv/HGG0O3sS9z4q932tZFnTR/SxcNEN1xxx1ur1sNgvpbVPoDHIifzrW///67O/7Uphq8UJ9B32v/8ClTptjTTz/tgmttveW3qYIUDXJqQAOnP4Y/+ugj10/zgwv117SNn65/4X766Sd3/tDWaBdffLEbsNOECFtFxa9v376ufXW8ql3l/vvvd1uqarC4QYMGbmBI/TZd7/Q4bcmlrbi0T7MGL+gTJ7/fduedd7pt/Lp06eL6v+qvPfzww6H3YsOGDW7LT32ordXuqS7V5sqRYamolgqUKcXQp+rVWm+mrUnCUy5UUEAFjbQFhLZ2mDZtGikwp6F1UEpJVkqntsTQmh2lZmmNqk+ph0oXV6qX1kv5qV8qvuVXR0Ti2lmpQlp36lddDq9srXRxrdfxC77QzilLR1QhIp/W+6pqqh4TvlREKYh6L7QeO/baKcS/3k9rJP2CRDo/qP0efvjheNekqiq+zit+NXEk73oXTtc71cRQsT5hmc7p6ThU4Uil1av2hc63qi3i05ZFqvqrZQ+LFy8O3T5o0CB3/mBN8Olpe0kVjfMrsofXZtA2k+qfaemZlpX4BVF1TlFxVf0MO7wkTNcw1Qbw64fo797/29fWW6onoHRxpS/7RSSVCq5q+KqB4Z+3kfJ+m5aLqE+sx9SvX98d1+p7aKcM1YZKy23lsuif1A/rkVEo9WL48OFulL5ixYp2+PBhN7opt9xyi5tx2r17txs1atOmTWj2yU+txelHQTXCFj4KqhF7zarWrFnTHn/8cTdipxHQ1atXW+/evV3bauZv0aJFbpS5QoUKNPNp9OnTx82KKCXLH833j+Err7zSHnjgATe6rBm/nTt3ulRQfzZVI6e0c/Jm/TSSr9v92T1lueh2pSrHznJRWr4/O4jEZbpUrlzZnn32WXfc6nadLzSbrSwBHdeittVMi0bxmZUK5nqnc8i9997rZqJ03du2bZt9+umnHLanoeuXZq9HjRrlzgk617711ltutklZcP5MtdLDda6WHj162HfffefeG87Dp6f+gWb4Nm/e7Gb3NJPqLwlRxpuWPjRt2tS19cyZM11a+DvvvMOxmwQ6n+q8q36D+mr+0jEt4dNxqvOw30ebN2+e6+NpmQmC67c1bNjQtb9CWGUJbNmyxZ1bdC6WK664wv2MztlpJs1Ce2SIQgIqOqICUNqrL3yvOY3Yq6KnRqG7devmZk80KurzZ7XZ1y/lo6D68PdK1Oi9ipqpgm1q7OMXDVTVV+3sV6j1C2SIRjn1oWJQKv7kZw1oBF8jovo52vn0yHJJH5kuX331lavYruJbmqnSOUTFozSqn5Yj+dF4vdM2PKIdHdTmysTgehc/zTxVq1bNVQ0P30pOWQDKDtB1UFud+dWstd2Ojl21tdpeWQRIHM2QKuNNxZ38jDcVSVVmhorG+fxdSPzt/ZB4/rZ82r9d/Tadj2MXoVV/TRkusXfQQLD9NmW9pEcE2EgQJ+rIUcdMJ5B+/frF2CpH1VPVodBn7WH7yCOPuJO0f6JRB4XKk4mjTtz48eNdO/tpnD5dELX1lvYa1762OmGrM+en1Wl7HfYTDy4dURU//c51+HYlOL3XXnvNVVQOT49VZ+O2225z1X4PHz4c2sFBx6yqMuuYVlCzcOFCKgFH6HqnNEVtfUTafcK+//57114aiPM7yf5ghI5RLXVSOq2ue9rO00/Pnz59ute2bVuXWouE6RygLTr9beH8Y1mDcI8//rg7hsO3ovTfFw0oxd4eDafSoLv2u9+yZUvo2qWtJXVc+5MeGvwU/3710xo3bhyaIEHk+m2xJ0LSw2AnATZOwYk6fY6CqqOHpNNMlLaS00l54MCB7ra4tuL67rvvvMqVK7MvZRKQ5ZI+M12QOtc7agYkXpcuXVwQPWLEiFBb6zysddU6bjX4pm0StSZb2076WK96erq+Pfnkky4TQDN6fv0QHdfKtND5Q2vfff4gh7aa03HOmuuE6ThVTQD1D7RNnCY+/ABOg0BqXw0kx25H1Q3QeVnrrpH5+m0skkUMWqfnr53U2oXOnTvbZZdd5tZJdezY0VVI1JozrQ/21wurFL62eVDlZb9qLeKmNWdaw6c11WorbQulyqmqFL548WK3RYa2fFAlYH8duyqmFi1alO0ckkBbjqgauNpN631VHVwDiloDuGDBAlcRvH///m6djt/OWm9dpEgRti5KArWb1u89+uijbm2f1qzefPPNruKyPnSb1kpJ3bp17cknn3QVa1WB2a9gTSXrhKlSqqj6r9b8hq/389dd++v9tPPAJZdcYiVLlgz9PNXCI3e9YwujxFOldW07qZ1GtFWf1gir/VUhWNXCfdreTPep9oiq3muLRCTcrlr/72+PqmNU5wy/grXWBHfo0MFtFaVzQ5MmTdz5Qv2McePGuXoD9NsSbt+PP/7YnnjiCWvXrp2tWrXKGjduHLq/WbNm7lhVH047Zegx6neo3VVrQO2rbVeR+fptBNgI4UQdWeoQa19VbTWiAFsnYhXKUUEtdSRUkETBiF/szC8SpwIZ2oJABY1wegrstOWTtiXyT86NGjVyW+qonVVYTidofYS3s/ZpVrCn4kZImPby1DGpDw0AKZBWkK1iJF9//bXbLkq3+YGJqCiX9vz098FG4mgLI7Vz9+7d3QBG165dbcyYMa7zpkBQRYxEg3IqqKNzTHiAzQBG3LjeRZYGhNauXeuCD3WAr7vuOtfmOn51Dtbt+qzg2t87XHR7iRIl3EAGEqattT755BNXvMwvdupvf6g21X7hGqDwz8+6Nqrgma6NOodQ9DBhCqxVcE8F+PxCnfXr13fn1O3bt7vvdT1TH04DG88//7wriqj3QANJ+ggvzoVM1m9L6yl0pA/jxo1zqS/hhUSOHDniPisd0U/TUspRmzZt3Bo1rfPz109RgCRhSs9S4SFtW6T0b6W6bNq0KcY6EX89T8+ePd19/vpWtW/4ljFIuJ11HCu1SO0ce327jmPdV7ZsWZceF57KValSJdo5EUhHjDzW+0UW17vIUr9ABYhUg0Ep9kqf9YuXibbyrFOnjjd27Fhv165dodt1vVMKaHxbzeH/qN+gFFotYZg0adIp5w6lMGttapMmTVxKvt93u//++921T2n59NlO79VXX3W1Q8JT69evX+/6C9oSSseqtoLya+L4S/7UxvTZEi9a+23MYGdyGinSrIjSNrWFTviWT9rUXSN4X331ldt2R6kwKouv0VA9VumeGg1l64yEMQqaOrSdg1I6w0fz/dk9bd2grAGNdCrtSKP72j5Kx69GnkeOHMlocyIw6xd5ZLpEDte7yFPq8eTJk12KrL8Vl2b1lFLve/HFF12/Y+zYse5c3Lp1a3cO1of6E+EZGDiVrmOa8df2Zuqn+aZOneq2kNJykQsuuMBlDiilVum0Dz/8sHtPXnjhBWvfvr2VLl2apo2Hv6xm06ZNMTKulDGgraA0y6rsLGVaaImJ+sVqdy350+O1lEfp+Mjc/TYC7EyOE3XkLV++3KW1+ClGOjH8888/7oSsC6I6GlpXOWTIELv99tvde6J0UH3WySe9njzSmxUrVriUIn8vZbWzLpDam1kfoguiUvG1T6g6KD179nS3q50vvfTSNH396R3piJHHer/I4noXWcuWLXNLFHQtq1GjhrtNy0JEy0a0f7vOyxqs1x63ShdXMK5aAvpZBusTT+2oNdcKTg4dOuQmSfShAO+VV15x7a8gW4MYCgqValuoUCEXcCNh/rIapR3369fPBXpr1qyxdevWueNZKeNasqf2V+0c7Yn9999/u72ur7nmGpo3CVZEcb+NABucqCOEUdDUa2eN0P/222+uU+Gv5dPIpk7AGuDQxVCj+SqSoY6dRvJvueUWt35Yo6YXX3xxKr3ajIdZv9RBpkvqIDCJHBXw3LNnjytSJJpx0myqBpJ1fPu0rlWZcDoXd+rUyb777jsXaJctWzaCry66zsnKCtCaX2UTamBCM30aoH/ooYfctS6crnMKrpH49lWQrTo5GryYM2eOO6ZVwFNtrLbUY0T3a827aowgacfw8SjvtxFgZ3KcqCOHUdDUa2cVwVARHY02q4OnUVFV+yxcuLArBKUTtSr+aiRfo88HDx50lVObNm1KEahEtC/piJFHpkvkcb2LLBV3UvGhv/76y1UBVgrn559/7opttW3b1lUIVzCioFDFOxWsDBw40BWMoiJ70s7JGrxQBWUF11u2bHFV8BV0q301iCQqFKc0cqUs673RdZKih4lrXz/I1rF61113uaDa30XA/yzffvuta3tVbEfSjuEcUd5vI8DO5DhRRw6joKlL24/oJK3RT6XGafRZa/t0gvY7HDpxq6qqf3HMCCfp9IBZv8gh0yX1cL2LrMsvv9wF1to6zg+2lWbbo0cPlz7rV/7VbTpX+wiuk06DnpoB1GyePkRLz7TcTNc3DWqonoOqjCsIT4/bGKX3c4W/VZw/+6/11po1VZCnNGa1q6pYa7s5ZRAg6ZpEcb+NABucqCOEUdDUpRSup556yu1bqwtgXKPNSvXSaLM6gUgcZv0ii0yX1EVgEhmaUVUQp5lpfWgrP62rVCqnAkAFg34auR7nr81G4oXvae/vA6y9g1XoTNc5rQX2U5X1vWYEtQZbgxtI+vGs4Frrr/WhVOXPPvvMfejY1X1q9wkTJrC0IQWKRnG/jQA7k+JEnToYBU09/l6qOknLH3/8Edp7WSl0Gm3WOkB9VhVKJA6zfpFFpkvkcb1LvYELBc+q+BubP3uttHEVhKpatWoqvKqMTdWqtYNL8eLF3SyqUsB1LCv4UHtqxlqFn5577jm3P3OrVq3cbKqubxrYUMCtn0Xy+hL//vuvm2HVHuL333+/a1/NpmrGVfUCateubcWKFaN5U+BEFPfbsmivrrR+EUjbE7UO7tgn6q+//jrGifqmm27iRJ2Ck0f4KKiKu8QeBR0wYECoiiKS3846IatN1cnTuh6/OImCRM2cvPHGG7RzMvkzJj4/HVH8dEQVKNGFkBmT5AeAqrQc33o/bVGi9a3aComUxPhxvYssrZMsU6ZMvOdhpYfrHDx37lz79ddf3bY7Ol+o4JlSlt999112xzgNVWJXcThd01QZXOvVtR2U/3ev4E8DGXXr1rXevXuHzh/++SL8nIK4hZ9bY1P7KqDWsaticn4RLgTnRJT32wiwMwFO1OlrFFTbPWhrDUZBk2bevHlukEgn3RtuuOGUwG/jxo1uuwft8anCJNouRhUqtVZKxTK0PvC8884L/H2OVsmZ9Rs6dCgd52Ty1/v5tOVO7PV++tDAJ9WW48f1LrK0nlpBsip/hw/yhF/vxo0bZ/fee687Jyv9U+cNDRqpKJe222EP5oRpmy3N2j3zzDNuXar+7n/44Qd755133HafKvakvoQGObSnuH+e9ufLwpen4VS///57aM/luIJstV3nzp3dBJO2hApv37i+RvzmZeZ+m2awEb169+7t1apVy5s6daq3aNEir1OnTl7NmjW93377zd1/4MABr0WLFt4LL7zgnTx5MvRz+tr/Pvx2nOrEiRPxNss///zjNWzY0OvRo4d3/Phxmi+ZBgwY4F1++eVe9erVvTJlyniPPfaYd+jQodD9f//9t9egQQPv5Zdf9o4dO0Y7J8OKFSu8efPmuWPWb1v97fvH7YYNG7wrr7zS+/LLL70jR454M2fO9Fq3bu09+OCD3uDBg73169fT7snkt/HWrVu9ZcuWedu3b/defPFFr0aNGt5NN93k3XbbbV7jxo295cuX08YJ4HqXOu2rYzSua6DOHXXr1vW6d+8eum/nzp3eTz/95M4fe/fujfArjI42vuyyy9z52KfzcOXKlb133nkndJv6cPTNkm727NlevXr1vHHjxiXYhzt8+HAynh3hBmTyfhsBdhTjRB1ZS5cuTfAErYvfk08+6XXr1u2UwYu4vkb8x7ECje+//951Kj799FOvQoUK3ogRI0Jt2KVLF9fWtGfyKEDWQFC5cuW8OnXquAvjvn37Qver46wL4bPPPhujjf3jnnZPeXCtNq5SpYo3cuRI156rV6/23nrrLe+VV15xA6QbN25Mwf8S/bjeRb591VH2A7/YHeItW7a4c4QG6/3zQkKDzzjVa6+95iZAVq1aFWpjtaEGNFu1auUGN8PpPs69SbNy5UrXV9DA5YQJE2K0pY/JkJTrTb+NADtacaKOLEZB067TrMDv9ttvdzN8PmVi0NFIfhuT5RJ5ZLpEDte7yHr11Vdd4BdXcP3vv/+6c+/PP//svf3225yHk+mLL75ws3waTJPw69l///tfN/j5+eefe0uWLPHWrFmTsjc0k9MARufOnb0mTZrEG2TLnj17vIMHD6bBK8zY6Lf9H6qIR6FZs2bZ6NGjXUEcrXVSpoJfnEhFM37++WdXHGPp0qVuDVWJEiXiLfSAuKm4U40aNdzefWo7tWfsgkRak5bRthVIT/r27evWoU2ePNlKliwZWqOqY1ZbNoRv85I3b173+X9ZORzPSVjrp3NC+FYjl112mavwu3DhQrfeT22r4ofauzZ8zVl8XyPu9X6xzw8+Ha8qcqi1Zlrfynq/pOF6F1kqyKmtntSn0DkivFaA1rtrbfCwYcOsWrVq7gPJo/6Ezr1qS627rl69urtd665V1FDrgdXeKnIo6redccYZrjht+NpWnGr79u3uQ7SeV/3ihx56yLX1pEmT3O1+H863detWV9xM/Y3XX3+dPkUi0W/7/wiwoxAn6shTcREVZdDFL/YJ2u9E+1UnVeBFHZKMtsVAWlK1WVWabdasmQuuxW9PFXyZPXu2XXLJJS4AV7CtKqvq/GlQI7zSNRK+EE6fPt21pzocKjqi41afFUyrIJFPgbaOayGYTjxVQ33ppZdc9d/WrVvHGWSrPTXQEXswjgGMxOF6F1kK9rQrwMCBA905wR/Y1K4BKrjXp08fd/5Fypx11ln29ttv28MPP+wKwWlQY+bMmTZq1Ch3rtY5WNXZFSiqSr6KIGq7M10HET/10X788UdbvHix60OoKrgqVatfER5ka6BTVcNl8+bN1r9/fzfIrH4IE1CJQ78tJqqIRykFdTpRqxJf+In6hRdeiPdErZMOJ+vEj4IWKFDAjSbrBK12bNmy5Sn7fzIKmjyqLKktn1SttmnTpq4SrQwfPtxtc6aRe+0/qSwM0eCFOijasiS86ifin/V7/PHHXZZL8+bNY1REVWfj5ZdfdrOqOs79LBckbzsjBSI6T2ibHf/8EDvThS1gUobrXWTp+qaqyjpONSin2Wydi/3MCySPzgs6F6gvoW2J/GNZg/e6tmk7VQ1s1KtXL86fVzVxP3sLp3rttdfcILwGLC688EJ3ndO1TANC/jaTa9eudbtf+H24m2++2Q2K6hqpPkhG3B4qrdBvi4kAO0pwok6bUVAFJeFBdosWLU4ZBdVsq0ZBNbCBpJ2slR6uFGalwamzoeBao/maYdX2RRs2bHBBjN4DDRQpEGcLo9PTthnaNk4DRtpDNXY6otpaHT7SEVPujz/+cO0aexAu9kw2mS6Jx/UudYQPvOn47dSpk9unXZSuXKtWrVR6JdFHe/sqiFOQrK0Pn376abvjjjvcfdrCU9sgakZwzJgxoS2l/Pcjof2b8X8UHOu8O3jw4FD7+UaOHOkGiTTh1Lhx4xhBtpZAaF9mZWeUL1+e5kwi+m3/HwF2FOBEHVmMgqZdhoAudEph1lp33afZ1SpVqpyyZzCSjlm/yCDTJbK43kWW9rHW/vY6/8amve61nEEDm9OmTSM1PJmUOaT20yC9sq/8Pa51rfMH4nV+fvDBB10WnAbqdd0jMytxlKGpAYpLL73U7RcePlCkjCJldWpG+88//3QZb9dff70btNP7oWNcEyYM1CcO/bYE/K/YGTIobeGi6p7fffed2+d60KBB3qWXXhra59qvhKi9rrWH7S+//EKVzySYOHGia7fwLbl82pNSWxqpsqeosqdfmfK6665zW+7E3i8UcdOWW23atHFtpqrh4Vtubd68ObSforaTim8rDaqIJ0zbPv3xxx/epk2bYpwbWrZs6c4ZanedR+KjSu1I/nGs9vfPD+PHjw/9jN4P3a6fCT9v41Rc7yJr1KhR7jh86KGHvM8+++yUv3mdc7UX+w033OA1a9bMbc2FpOnVq5frs6kauE/bcKmPpv6G9gn2q7Rrxwzdfu2113oLFy6kqRNJe67rOI69rdn777/vqrHPmzfPfd+1a1evWrVqru8sa9eudf0NJA79toQRYGdgnKgjSxc9dZDV6YgdwA0fPtwF1wpO1JGeMWNGqBOtzon2Aw3fWgrx69Onj1e3bl1v2rRp3uLFi90g0K5du0J7A8vWrVtDQbY++9hnNXE08KZOsfa61l62kydPDt23e/du7+GHH3a3hw8k+cc7bZzy41gdvtiDcNoeZv/+/d7TTz/tVa5c2QUuiB/Xu8hSUPfcc8+5raK6devmPt92223ufKtzxOHDh0PnA13bGjdu7DVv3pyAJAneffdd165///23+17BtE9tee+997p27dSpkxvg8INsnS+aNm0aeg+QsHXr1rm+woIFC9z3R48edce3tlfVedmnfoXejzFjxtCkSUS/7fQIsDMoTtSRxyho+soQ8INsBYnaZxGJw6xf5JHpEllc71KHAj8NtCng+P33313AV6FCBXeO1myfbtPAs/z555/eFVdc4QaZY2cT4VTKBlBQomtaeCaWPxOodtb9+mjUqJF30003uQF72bt3b2iwGaeKnb2mgYt69ep53bt3T/Bx2nP86quv9tavX0+zJgH9tsShSkIGpKIYqg6uIk9axyMqSiRax6N1Jap82LBhQ1u2bFmoiq2qAWuNj7aCYH/m01N133z58rn1aKJ1v9rCSO2uAhh16tRxtz/55JN24MABt9+taCuTIkWKROz9j6Z1UipMpqJwKkKiAT+fjlkVIdE6qe7du7sq+IULF7a77rrLrr32Wps7d67t3LkzTV9/RqACZjpHqKiLKtGqmJl2F1B769xw+PBhd0zrGNdjtOXZM888494XBH8cf/75566KrbaHUQVbtb+K8VBMJ35c71KHCmfpunXNNdfYjBkzrHjx4m5Nqq51lStXto8++sgV8XziiSdC2yOqv6Gik1TBj59/PlC173vvvdddw95//323t7Lo/KB2fOutt1y1a51/n3vuOVdwS5WuRevhVZcEcdu3b58dOXLEnYtFW3Vqd4zvv//eVb33qQ8XTudt9ZXVp0Pi0G9LgkQG4kgHwkfftG5vyJAhbgS5b9++7jalMteoUcP79ttvQ4/95ptvXAqMPiPx7SuMgqbPDAGt+9uxY0eEX13Gx6xf6iDTJTK43qVe+4Z//cUXX7iaDB999FHotmeffda7/vrr3YygUm/Vp7j//vvdEgckTHUu1Jfw07s3btzoZrA1w6r11bVq1QqlMvuZAMoOUB2XuXPn0rynoUw3ZVooxV7L87Zt2+Zu1zIGpdXffPPN3ocffhjjZ3TcDhw40PWX1dZIPPptiZc9KcE40n6ULmfOnK4aorbQufXWW93o6AcffGA///yzrVu3zm1jVLNmzdDeqhr11IyqRvRw+vbVzL7aV+3sj4JqBFQfN910U2gUVPf7GAUNLkNAbe9nCFStWjWUIaDZE2UIaAZWMydI2qzfY489dkqWi2ZcNXr/1Vdf2Zo1a6xMmTJWsmRJl+WiCrZkuUT2ONZ5GfHjepe61zt/Z4ZGjRrZFVdc4c4T2hNY1Zg1E6hsDGVa+Fsj6lyh4x7xU1aQsq10PtV1SxWrixUrFtqOSzPZNWrUcH22cMoQ0DZcpUuXpnlPU41dbaXt41T9ft68eda2bVubMGGCqwLeo0cP9xhlC8yZM8fq16/vtuRS5etff/3VVRMvVaoUbZwE9NsSj6grg+BEnXrtqzQ5XQjPOecct33D119/7U7ESqXVoIYfXCstXJ2QL7/80gUlSsFH/MK3yhC1szoRn3zyietg+NtuXXXVVTEep/dF6bS6HYlrYz8dUR1g7SWuVGTtsxqejqiUcT22du3a1r59e5eOqE6z0hHj2qIHHMephetd6rWvzsO9evWyQoUKhQbmda5V6reW4yjw1h7B/jKGCy64wH0g6cFfu3bt3KCb2jw8yNZWoEoNV9sPHDjQ9Td03tayKCS8/Cl8n/Bq1aq5dlcArWvYZZdd5rY4+/bbb93gptpa18YGDRq4pQ4cx6dHvy35CLAzAE7Uqd++jIIGjwyByGPWL3XamEyXyOF6lzbXOwV+/oy0gr8PP/zQ1Wn49NNPXd0ABBf8aTBeQfbdd9/t7lMwrQwj7Ymtn9GAvbKLEDdlaqqNVJtFQbIGkNV+ygw6dOiQTZ061WVaqA6RZq3vuece19Zap60AG4nH9S75CLDTOU7Uadu+jIIGgwyByGPWL3XbmEyX4HG9S9v2DU/51vKo5cuXuyCbADu44G/KlCkuW0jBn2ZSlWmkTK7hw4e7LDnNsvrvDU6dTVXbKYBWRsWOHTtcG/vLn8aPH+9uW7FihTtHd+3a1WVnabZa2QF+cB17VhZx43qXMlm0EDuFz4EInqhV8Tv2iVqpyTfccIM1a9YsxolaJ2mdYDhRB9e+4aOgWlOpFDpGQVM+Y6JKlFonpQEM1Q/QY3Qsq7MXe53UkCFDqLKczDbWrJRmS7Zs2eI6bvpo0qSJS0cUpSOqs60ZFGZMOI7TEte7tG9fnTt0vbv88svd/S1btnR9C6WQI3HBnwJmpdt369bNqlSpErp/2LBh7j3QkhwFf0uWLLEHH3zQ1WZQvQwtldL6d2oznN6CBQtchXv1Hx544AG3o4uWPqnvq9u15EzBtAaUlImh9ddUCk8a+m0BSEJBNKQSVfTUfpTae/K2227zFi9eHOP+t99+21X5bNu2rXf77be7ip79+/cPVagcPny4t3btWt6vANtX+y/HrjIe+3ucqlevXm5f1fB9rlXRXhVS16xZE7pt3bp1ruq1Kn6qGujdd9/t9gbV+4Tkt3H4eUCV11W9VlWABw0a5M4TFStWjHMPcnAcpxaud+mvffv16xc6t2jfZu3hzPUucebPn+/auU2bNqGdMHQtu+yyy7yvv/7ataXfttpFY/v27e579hJPmCqtT5o0yRs3bpzbH1x7st96663eww8/7Krcqxr7Dz/8EDrmZcqUKd4111zjbd68OUl/M5kd/bZgEGCnY5yo01f7sjVU0mgbufLly4eCZG1V4m+RUb9+fdeJ69ixo9sOxm9bdTL8dkcwbfzEE09406ZN83bt2uW2jHnzzTddYK2t0AiuOY7TC6536ad9K1eu7O3cudNtdaRteZAwgr/I0gTHDTfc4N14441uay0NwPsDyRqQr1Chghsw9p04ccJ97tmzp9eqVStv3759EX6F0YN+W3BYg53OLFy40KXHKr2zbt269uKLL7qtBpT6rRQibakzePBgd5+f3a/UTlW81vod0VoTBN++qqaK02OdVPprY6WE++mIt9xyS2g7HtIROY7TEte79Nm+fkVxbXWEhGmZzezZs92a3q1bt9oXX3zhlj9pa8Q33njDbXGmr9XG4et/tb5d262y1dnp21dLmNSWutbt3r3bFYMTLV9QKrjSmbVdqu7XFnNaLjlo0CC33n3SpEns8JII9NsiIMBgHSnEKF1k0b6piwyB9NfGpCNGvo3JdEkczseRRfumThsrNVnniL1797pMom3btoXuX7hwoZthfeCBB7zvv/8+dPvAgQPduWLlypWp8CozLmVYqf3UvrHpts8//9xbvny5N2PGDO+OO+5wyxx++eUXb9iwYSx/Siaud8FhBjudYJSO9o0GZAik7zYmyyXybUymy+lxvYss2jfyfv/9dzc7rZnVWrVqudtUdMsvwrVr1y678MILXREu7WutD81W69wyevRoV2m8TJkyqfBKMy4V59y/f7+VKlXKfX/y5Ek3U609rfXh0/7iKi737rvv2iOPPOIK96l9qcaeOFzvIoMAOx3gRE37RgNS5WjjaMBxHFlc72jfaEDwF3k5c+a0XLlyud1ENIihKuwzZsxwezO3adPGVWRXtfuOHTvaf//7X3v66addargGQy+55JJUeIUZH9e7yCHATgc4UdO+GR0zJrRxNOA4jjyud7RvNCD4i7zSpUu7mkLPPfec7dmzx31dsWLFUACdPfv/hTDaDm3RokWuzsiIESNC+10jYVzvIosAOx3gRE37ZmTMSNHG0YDjOHVwvaN9owHBX+QVKVLEzVorFV8p91WrVnVp30rF95c7bdu2zRXt9At2+gXQkDCud5FHgJ0OcKKmfTMyZqRo42jAcZw6uN7RvtGA4C91nH/++XbnnXeecrs/ez1u3DhXvb1SpUrue1Vox+lxvYs8Aux0gBM17ZuRMSNFG0cDjuPUwfWO9o0WBH+pSzPZf/31lwumlTKu7z/++GMXZGvLMyQe17vIy6JS4qnw/yCF+vfvb7NmzXJVEjmRBI/2TdlIaPv27W3Tpk0JrpNq2bKlXXXVVW6d1MGDB1knRRunKxzH6QfnY9o3moI/7c+MlPvxxx/t0UcfdTs3aK/2Cy64wLp27eqyYpA0XO8ijxnsdIhROto3I2FGijaOBhzHaYPrHe0bDTSQPGTIkBjBn7aKIvgLTp06dWz69Om2fft2O/PMM107+1ujIWm43kUeAXY6xIma9s1oSJWjjaMBx3Hq43pH+0YDgr/UO0frA8G0JevbI4cU8XTqn3/+YZSO9s2QSJWjjaMBx3Hq4XpH+wJIO1zvgscMdjrFKB3tm1ExI0UbRwOO49TD9Y72BZB2uN4FjxlsAIFjRiryaGPaGAAA+hTpDwE2AAAAAAAByBrEkwAAAAAAkNkRYAMAAAAAEAACbAAAAAAAAkCADQAAAABAAAiwAQAAAAAIAAE2AAAAAAABIMAGAAAAACAABNgAAAAAAAQgexBPAgAA0p+uXbvaRx99lOBjatasaePHj4/I/79gwQK75557bNy4cVarVq2I/B8AAKQnBNgAAESpRx55xFq2bBn6fujQobZ8+XJ78803Q7flz58/jV4dAADRhwAbAIAoVbx4cffhO/vssy1nzpxWpUqVNH1dAABEK9ZgAwCQiU2dOtXKly9vH3zwgV1++eUuZXz16tXuvtmzZ9stt9xiFStWdPf16tXLDh48GOPnf/31V7v//vutWrVqVrt2bXvyySdty5YtMR6zZs0aa9u2rVWuXNk9T79+/ez48eOh+48cOWJvvfWWNW7c2P1fjRo1shEjRtjJkydTqRUAAAgGM9gAAGRyJ06csNGjR1vv3r1t165dVrJkSfvkk0+sc+fO1rRpU3viiSfs33//tYEDB7rge8yYMZYlSxaXbt6qVSsXOPft29c9T//+/V0wPW3atNDzv/rqq/bQQw9Zu3btbM6cOfbOO+9Y0aJF3c96nufuU6D+6KOPWtmyZd3a7UGDBtmGDRusZ8+eado2AAAkBQE2AABwQW7Dhg1dSyjo1SxzvXr13GffRRddZPfdd599++237rHDhg2zM8880wXnuXLlco8599xz7amnnrI///wz9HMqdKb14KJZbs2Mz58/3wXY3333nc2bN88GDBhgN954o3uMZrlz585tb7zxhvvZSy65hHcIAJAhkCIOAACsXLlyMVK6N2/ebFdddZVL5fY/atSo4Yqi/fDDD+5xP//8s9WvXz8UXEvVqlXtq6++ivF81atXD32tme/zzjvP9u7d675fuHChZc+e3aWHh2vWrFnofgAAMgpmsAEAgOXNmzfUCrt373afX3rpJfcR29atW0OPK1So0GlbL0+ePDG+z5o1q5sllz179thZZ51l2bJli/GYwoULu8/79u3j3QEAZBgE2AAAIIaCBQu6z126dHFFz2I744wz3OcCBQrYzp07T7lfKeThM9gJ0XNp3bfWb4cH2X4Qr+AbAICMghRxAAAQw8UXX+xmpv/55x9X1dv/KFKkiCtipuJmfuq30sWPHj0a+lnd9+CDD9qyZcsS1aoK4JV+PnPmzBi3f/zxx+7zZZddxrsDAMgwmMEGAAAxaCa5U6dO9sILL7ivr7zySrdmeujQoW4LrksvvdQ9ToXLWrRoYe3bt3fFyA4fPuyqf1eqVMkVKlu8ePFpW1ZruGvVqmXdu3d3z60q4lp3rUrjzZs3t1KlSvHuAAAyDAJsAABwittvv93y5ctnI0eOtMmTJ7s12trrWlXFL7jgAvcY7Z89fvx4N6utrbxUAK1BgwZue6+cOXMmqlVV9Gz48OE2ePBgGzt2rEs5P//8891+2m3atOGdAQBkKFk8v8oIAAAAAABINtZgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAAAgAATYAAAAAAAEgwAYAAAAAIAAE2AAAAAAABIAAGwAAAACAABBgAwAAAAAQAAJsAAAAAAACQIANAAAAAEAACLABAAAAALCU+38uLWkPawbBKAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1. Filtro e Limpeza C-99A\n", + "df_c99 = df[df['Modelo'] == 'C-99A'].copy()\n", + "df_c99 = df_c99[df_c99['Localidade Decolagem'] != 0]\n", + "df_c99 = df_c99[df_c99['Localidade Pouso'] != 0]\n", + "df_c99['Trecho'] = df_c99['Localidade Decolagem'] + '-' + df_c99['Localidade Pouso']\n", + "df_c99['PAX'] = pd.to_numeric(df_c99['PAX']).fillna(0)\n", + "df_c99['Dep TimeStamp'] = pd.to_datetime(df_c99['Data de Decolagem'] + ' ' + df_c99['Hora de Decolagem'], format='mixed', dayfirst=True)\n", + "df_c99['Data Apenas'] = df_c99['Dep TimeStamp'].dt.date\n", + "\n", + "CAPACIDADE_C99 = 50\n", + "matriculas_unicas_c99 = df_c99['Matrícula'].unique()\n", + "total_aeronaves_c99 = len(matriculas_unicas_c99)\n", + "\n", + "print(f\"Total de matrículas únicas C-99A (aeronaves disponíveis): {total_aeronaves_c99}\")\n", + "\n", + "# Demanda diária\n", + "demanda_diaria_c99 = df_c99.groupby(['Trecho', 'Data Apenas'])['PAX'].sum().reset_index()\n", + "\n", + "import itertools\n", + "todos_trechos_c99 = demanda_diaria_c99['Trecho'].unique()\n", + "idx_c99 = pd.MultiIndex.from_product([todos_trechos_c99, datas_2025], names=['Trecho', 'Data Apenas'])\n", + "demanda_diaria_completa_c99 = pd.DataFrame(index=idx_c99).reset_index()\n", + "demanda_diaria_completa_c99 = pd.merge(demanda_diaria_completa_c99, demanda_diaria_c99, on=['Trecho', 'Data Apenas'], how='left').fillna({'PAX': 0})\n", + "\n", + "estatisticas_trechos_c99 = demanda_diaria_completa_c99.groupby('Trecho').agg(\n", + " Media_PAX_Diario=('PAX', 'mean'),\n", + " Desvio_Padrao_PAX=('PAX', 'std'),\n", + " Total_PAX=('PAX', 'sum'),\n", + " Dias_Operados=('PAX', lambda x: (x > 0).sum())\n", + ").reset_index()\n", + "\n", + "estatisticas_trechos_c99['Media_PAX_Dias_Operados'] = estatisticas_trechos_c99.apply(\n", + " lambda row: row['Total_PAX'] / row['Dias_Operados'] if row['Dias_Operados'] > 0 else 0, axis=1\n", + ")\n", + "estatisticas_trechos_c99['Score_Relevancia'] = estatisticas_trechos_c99['Total_PAX'] * estatisticas_trechos_c99['Dias_Operados']\n", + "estatisticas_trechos_c99 = estatisticas_trechos_c99.sort_values(by='Score_Relevancia', ascending=False)\n", + "\n", + "NUM_TRECHOS_C99 = 10\n", + "top_trechos_c99 = estatisticas_trechos_c99.head(NUM_TRECHOS_C99)\n", + "\n", + "display(top_trechos_c99)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(data=top_trechos_c99, x='Trecho', y='Score_Relevancia', hue='Trecho', palette='magma', legend=False)\n", + "plt.title(f'Top {NUM_TRECHOS_C99} Trechos C-99A (PAX * Dias Operados)')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Rede C-99\n", + "G_c99 = nx.DiGraph()\n", + "for _, row in top_trechos_c99.iterrows():\n", + " origem, destino = row['Trecho'].split('-')\n", + " G_c99.add_edge(origem, destino, weight=row['Score_Relevancia'])\n", + "pos_c99 = nx.spring_layout(G_c99, k=2.5, iterations=100, seed=42)\n", + "plt.figure(figsize=(12, 8))\n", + "nx.draw_networkx_nodes(G_c99, pos_c99, node_size=1200, node_color='lightcoral', edgecolors='black')\n", + "nx.draw_networkx_edges(G_c99, pos_c99, edgelist=G_c99.edges(), arrows=True, arrowstyle='-|>', arrowsize=25, edge_color='gray', width=2, node_size=1200, connectionstyle='arc3,rad=0.15')\n", + "nx.draw_networkx_labels(G_c99, pos_c99, font_size=12, font_weight='bold')\n", + "plt.title('Diagrama de Rede - C-99A', fontsize=14)\n", + "plt.axis('off')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4475f157", + "metadata": {}, + "source": [ + "## MODELO 4: Minimização de Distância (Custo)\n", + "Equivalente ao Modelo 1, mas para C-99A.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "32c7a014", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-07T23:57:36.343895Z", + "iopub.status.busy": "2026-06-07T23:57:36.343763Z", + "iopub.status.idle": "2026-06-07T23:57:36.361322Z", + "shell.execute_reply": "2026-06-07T23:57:36.360699Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "== MODELO 4 (C-99A) ==\n", + "Status: Infeasible\n", + "Distância Total: 6280.78 km\n", + "\n", + "Trecho: SBBR-SBGL | Alocados: 1 voo(s)\n", + "Trecho: SBGL-SBBR | Alocados: 1 voo(s)\n", + "Trecho: SBGR-SBBR | Alocados: 1 voo(s)\n", + "Trecho: SBBR-SBGR | Alocados: 0 voo(s)\n", + "Trecho: SBGL-SBGR | Alocados: 1 voo(s)\n", + "Trecho: SBBR-SBAF | Alocados: 1 voo(s)\n", + "Trecho: SBAF-SBBR | Alocados: 1 voo(s)\n", + "Trecho: SBBR-SBSJ | Alocados: 1 voo(s)\n", + "Trecho: SBGL-SBSJ | Alocados: 1 voo(s)\n", + "Trecho: SBGR-SBGL | Alocados: 1 voo(s)\n" + ] + } + ], + "source": [ + "# Preparação Modelo 4\n", + "rotas_lista_c99 = top_trechos_c99['Trecho'].tolist()\n", + "\n", + "distancias_voo_c99 = {}\n", + "for r in rotas_lista_c99:\n", + " origem, destino = r.split('-')\n", + " distancias_voo_c99[r] = calc_distancia(origem, destino)\n", + "\n", + "voos_requeridos_c99 = {}\n", + "for _, row in top_trechos_c99.iterrows():\n", + " voos = math.ceil(row['Media_PAX_Dias_Operados'] / CAPACIDADE_C99)\n", + " voos_requeridos_c99[row['Trecho']] = max(1, voos)\n", + "\n", + "prob4 = pulp.LpProblem(\"Fleet_Assignment_C99_Brasil\", pulp.LpMinimize)\n", + "X_c99 = pulp.LpVariable.dicts(\"X_c99\", rotas_lista_c99, lowBound=0, cat='Integer')\n", + "\n", + "prob4 += pulp.lpSum([distancias_voo_c99[r] * X_c99[r] for r in rotas_lista_c99])\n", + "\n", + "for r in rotas_lista_c99:\n", + " prob4 += X_c99[r] >= voos_requeridos_c99[r]\n", + "\n", + "prob4 += pulp.lpSum([X_c99[r] for r in rotas_lista_c99]) <= total_aeronaves_c99\n", + "\n", + "prob4.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"== MODELO 4 (C-99A) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob4.status]}\")\n", + "print(f\"Distância Total: {pulp.value(prob4.objective):.2f} km\\n\")\n", + "for r in rotas_lista_c99:\n", + " print(f\"Trecho: {r:10} | Alocados: {int(X_c99[r].varValue)} voo(s)\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "921176a9", + "metadata": {}, + "source": [ + "## MODELO 5: Minimização de Frota C-99A (S/ TAT)\n", + "Equivalente ao Modelo 2.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0e7565cb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-07T23:57:36.362787Z", + "iopub.status.busy": "2026-06-07T23:57:36.362646Z", + "iopub.status.idle": "2026-06-07T23:57:36.963443Z", + "shell.execute_reply": "2026-06-07T23:57:36.962899Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velocidade média C-99A: 536.65 km/h\n", + "\n", + "== RESULTADO DO MODELO 5 (C-99A) ==\n", + "Status: Optimal\n", + "Aeronaves mínimas: 1\n", + "Tempo total de voo: 922 min (15.37 h)\n", + "\n", + "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", + "|------------|----------|-----------|------------|-----------|-----------|-----------|\n", + "| Aeronave 1 | SBSJ | SBBR | Vazio | 00:00 | 01:34 | 94 min |\n", + "| Aeronave 1 | SBBR | SBSJ | Passageiro | 01:34 | 03:08 | 94 min |\n", + "| Aeronave 1 | SBSJ | SBGL | Vazio | 03:08 | 03:38 | 30 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 03:38 | 04:08 | 30 min |\n", + "| Aeronave 2 | SBBR | SBGR | Passageiro | 00:00 | 01:35 | 95 min |\n", + "| Aeronave 2 | SBGR | SBBR | Passageiro | 01:35 | 03:10 | 95 min |\n", + "| Aeronave 2 | SBBR | SBAF | Passageiro | 03:10 | 04:52 | 102 min |\n", + "| Aeronave 2 | SBAF | SBBR | Passageiro | 04:52 | 06:34 | 102 min |\n", + "| Aeronave 2 | SBBR | SBGL | Passageiro | 06:34 | 08:16 | 102 min |\n", + "| Aeronave 2 | SBGL | SBBR | Passageiro | 08:16 | 09:58 | 102 min |\n", + "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", + "| Aeronave 3 | SBGL | SBGR | Passageiro | 00:38 | 01:16 | 38 min |\n" + ] + } + ], + "source": [ + "# Velocidade Média C-99A\n", + "df_c99_spd = df_c99.copy()\n", + "df_c99_spd['Tempo_Horas'] = pd.to_timedelta(df_c99_spd['Tempo de Voo']).dt.total_seconds() / 3600\n", + "df_c99_spd['Dist_km'] = df_c99_spd.apply(get_dist_row, axis=1)\n", + "df_valid_c99 = df_c99_spd[(df_c99_spd['Tempo_Horas'] > 0) & (df_c99_spd['Dist_km'] > 0)].copy()\n", + "df_valid_c99['Velocidade'] = df_valid_c99['Dist_km'] / df_valid_c99['Tempo_Horas']\n", + "vel_media_c99 = df_valid_c99['Velocidade'].mean()\n", + "print(f\"Velocidade média C-99A: {vel_media_c99:.2f} km/h\")\n", + "\n", + "aeroportos_malha_c99 = set()\n", + "for r in rotas_lista_c99:\n", + " o, d = r.split('-')\n", + " aeroportos_malha_c99.add(o)\n", + " aeroportos_malha_c99.add(d)\n", + "aeroportos_malha_c99 = list(aeroportos_malha_c99)\n", + "\n", + "tempos_voo_min_c99 = {}\n", + "for o in aeroportos_malha_c99:\n", + " for d in aeroportos_malha_c99:\n", + " if o == d:\n", + " tempos_voo_min_c99[(o, d)] = 0\n", + " else:\n", + " dist = calc_distancia(o, d)\n", + " tempos_voo_min_c99[(o, d)] = int(round((dist / vel_media_c99) * 60))\n", + "\n", + "D_c99 = {(o, d): 0 for o in aeroportos_malha_c99 for d in aeroportos_malha_c99}\n", + "for r in rotas_lista_c99:\n", + " o, d = r.split('-')\n", + " D_c99[(o, d)] = voos_requeridos_c99[r]\n", + "\n", + "prob5 = pulp.LpProblem(\"Minimizar_Aeronaves_C99\", pulp.LpMinimize)\n", + "Y5 = pulp.LpVariable.dicts(\"Y5\", [(o, d) for o in aeroportos_malha_c99 for d in aeroportos_malha_c99], lowBound=0, cat='Integer')\n", + "N5 = pulp.LpVariable(\"N5\", lowBound=0, cat='Integer')\n", + "\n", + "prob5 += N5 + 0.0001 * pulp.lpSum([Y5[(i, j)] * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "\n", + "for no in aeroportos_malha_c99:\n", + " chegadas = pulp.lpSum([D_c99[(i, no)] + Y5[(i, no)] for i in aeroportos_malha_c99])\n", + " partidas = pulp.lpSum([D_c99[(no, j)] + Y5[(no, j)] for j in aeroportos_malha_c99])\n", + " prob5 += chegadas == partidas\n", + "\n", + "tempo_total_voo_c99 = pulp.lpSum([(D_c99[(i, j)] + Y5[(i, j)]) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "prob5 += tempo_total_voo_c99 <= N5 * 1440\n", + "\n", + "prob5.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"\\n== RESULTADO DO MODELO 5 (C-99A) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob5.status]}\")\n", + "print(f\"Aeronaves mínimas: {int(N5.varValue)}\")\n", + "\n", + "tempo_gasto_c99 = sum([(D_c99[(i, j)] + int(Y5[(i, j)].varValue)) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "print(f\"Tempo total de voo: {int(tempo_gasto_c99)} min ({tempo_gasto_c99/60:.2f} h)\\n\")\n", + "\n", + "voos_para_fazer_c99 = []\n", + "D_copy_c99 = {k: v for k, v in D_c99.items()}\n", + "for i in aeroportos_malha_c99:\n", + " for j in aeroportos_malha_c99:\n", + " total_voos = D_c99[(i, j)] + int(Y5[(i, j)].varValue)\n", + " for _ in range(total_voos):\n", + " if D_copy_c99[(i, j)] > 0:\n", + " tipo = 'Passageiro'\n", + " D_copy_c99[(i, j)] -= 1\n", + " else:\n", + " tipo = 'Vazio'\n", + " voos_para_fazer_c99.append({'origem': i, 'destino': j, 'tipo': tipo, 'tempo': tempos_voo_min_c99[(i, j)]})\n", + "\n", + "tabela_horarios_c99 = []\n", + "aeronave_id = 1\n", + "\n", + "while voos_para_fazer_c99:\n", + " voo_atual = voos_para_fazer_c99.pop(0)\n", + " hora_atual = datetime.datetime(2025, 1, 1, 0, 0, 0)\n", + " tempo_delta = datetime.timedelta(minutes=int(voo_atual['tempo']))\n", + " hora_chegada = hora_atual + tempo_delta\n", + " \n", + " tabela_horarios_c99.append([f\"Aeronave {aeronave_id}\", voo_atual['origem'], voo_atual['destino'], voo_atual['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f\"{voo_atual['tempo']} min\"])\n", + " hora_atual = hora_chegada\n", + " local_atual = voo_atual['destino']\n", + " \n", + " while True:\n", + " prox_voo = None\n", + " for idx, v in enumerate(voos_para_fazer_c99):\n", + " if v['origem'] == local_atual:\n", + " if (hora_atual - datetime.datetime(2025, 1, 1, 0, 0, 0) + datetime.timedelta(minutes=int(v['tempo']))).total_seconds() <= 1440 * 60:\n", + " prox_voo = voos_para_fazer_c99.pop(idx)\n", + " break\n", + " if prox_voo:\n", + " tempo_delta = datetime.timedelta(minutes=int(prox_voo['tempo']))\n", + " hora_chegada = hora_atual + tempo_delta\n", + " tabela_horarios_c99.append([f\"Aeronave {aeronave_id}\", prox_voo['origem'], prox_voo['destino'], prox_voo['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f\"{prox_voo['tempo']} min\"])\n", + " hora_atual = hora_chegada\n", + " local_atual = prox_voo['destino']\n", + " else:\n", + " break\n", + " aeronave_id += 1\n", + "\n", + "print(tabulate(tabela_horarios_c99, headers=[\"Aeronave\", \"Origem\", \"Destino\", \"Tipo\", \"Partida\", \"Chegada\", \"Duração\"], tablefmt=\"github\"))\n" + ] + }, + { + "cell_type": "markdown", + "id": "dee63bf7", + "metadata": {}, + "source": [ + "## MODELO 6: Minimização de Frota C-99A (C/ 40 min TAT)\n", + "Equivalente ao Modelo 3.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "eefd3712", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-07T23:57:36.965022Z", + "iopub.status.busy": "2026-06-07T23:57:36.964881Z", + "iopub.status.idle": "2026-06-07T23:57:36.980280Z", + "shell.execute_reply": "2026-06-07T23:57:36.979683Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "== RESULTADO DO MODELO 6 (C-99A C/ TAT 40 MIN) ==\n", + "Status: Optimal\n", + "Aeronaves mínimas: 1\n", + "Tempo total operacional comprometido: 1402 min (23.37 h)\n", + "\n", + "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", + "|------------|----------|-----------|------------|-----------|-----------|-----------|\n", + "| Aeronave 1 | SBSJ | SBBR | Vazio | 00:00 | 01:34 | 94 min |\n", + "| Aeronave 1 | SBBR | SBSJ | Passageiro | 02:14 | 03:48 | 94 min |\n", + "| Aeronave 1 | SBSJ | SBGL | Vazio | 04:28 | 04:58 | 30 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 05:38 | 06:08 | 30 min |\n", + "| Aeronave 2 | SBBR | SBGR | Passageiro | 00:00 | 01:35 | 95 min |\n", + "| Aeronave 2 | SBGR | SBBR | Passageiro | 02:15 | 03:50 | 95 min |\n", + "| Aeronave 2 | SBBR | SBAF | Passageiro | 04:30 | 06:12 | 102 min |\n", + "| Aeronave 2 | SBAF | SBBR | Passageiro | 06:52 | 08:34 | 102 min |\n", + "| Aeronave 2 | SBBR | SBGL | Passageiro | 09:14 | 10:56 | 102 min |\n", + "| Aeronave 2 | SBGL | SBBR | Passageiro | 11:36 | 13:18 | 102 min |\n", + "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", + "| Aeronave 3 | SBGL | SBGR | Passageiro | 01:18 | 01:56 | 38 min |\n" + ] + } + ], + "source": [ + "# Modelo 6\n", + "prob6 = pulp.LpProblem(\"Minimizar_Aeronaves_C99_TAT\", pulp.LpMinimize)\n", + "Y6 = pulp.LpVariable.dicts(\"Y6\", [(o, d) for o in aeroportos_malha_c99 for d in aeroportos_malha_c99], lowBound=0, cat='Integer')\n", + "N6 = pulp.LpVariable(\"N6\", lowBound=0, cat='Integer')\n", + "\n", + "TAT_min = 40\n", + "\n", + "prob6 += N6 + 0.0001 * pulp.lpSum([Y6[(i, j)] * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "\n", + "for no in aeroportos_malha_c99:\n", + " chegadas = pulp.lpSum([D_c99[(i, no)] + Y6[(i, no)] for i in aeroportos_malha_c99])\n", + " partidas = pulp.lpSum([D_c99[(no, j)] + Y6[(no, j)] for j in aeroportos_malha_c99])\n", + " prob6 += chegadas == partidas\n", + "\n", + "tempo_total_op_c99 = pulp.lpSum([(D_c99[(i, j)] + Y6[(i, j)]) * (tempos_voo_min_c99[(i, j)] + TAT_min) for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "prob6 += tempo_total_op_c99 <= N6 * 1440\n", + "\n", + "prob6.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"\\n== RESULTADO DO MODELO 6 (C-99A C/ TAT 40 MIN) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob6.status]}\")\n", + "print(f\"Aeronaves mínimas: {int(N6.varValue)}\")\n", + "\n", + "tempo_voo_c99_6 = sum([(D_c99[(i, j)] + int(Y6[(i, j)].varValue)) * tempos_voo_min_c99[(i, j)] for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "tot_voos_6 = sum([(D_c99[(i, j)] + int(Y6[(i, j)].varValue)) for i in aeroportos_malha_c99 for j in aeroportos_malha_c99])\n", + "solo_tot_6 = tot_voos_6 * TAT_min\n", + "\n", + "print(f\"Tempo total operacional comprometido: {tempo_voo_c99_6 + solo_tot_6} min ({(tempo_voo_c99_6 + solo_tot_6)/60:.2f} h)\\n\")\n", + "\n", + "voos_para_fazer_c99_6 = []\n", + "D_copy_c99_6 = {k: v for k, v in D_c99.items()}\n", + "for i in aeroportos_malha_c99:\n", + " for j in aeroportos_malha_c99:\n", + " tot = D_c99[(i, j)] + int(Y6[(i, j)].varValue)\n", + " for _ in range(tot):\n", + " if D_copy_c99_6[(i, j)] > 0:\n", + " tipo = 'Passageiro'\n", + " D_copy_c99_6[(i, j)] -= 1\n", + " else:\n", + " tipo = 'Vazio'\n", + " voos_para_fazer_c99_6.append({'origem': i, 'destino': j, 'tipo': tipo, 'tempo': tempos_voo_min_c99[(i, j)]})\n", + "\n", + "tabela_horarios_c99_6 = []\n", + "aeronave_id = 1\n", + "\n", + "while voos_para_fazer_c99_6:\n", + " voo_atual = voos_para_fazer_c99_6.pop(0)\n", + " hora_atual = datetime.datetime(2025, 1, 1, 0, 0, 0)\n", + " tempo_delta = datetime.timedelta(minutes=int(voo_atual['tempo']))\n", + " hora_chegada = hora_atual + tempo_delta\n", + " \n", + " tabela_horarios_c99_6.append([f\"Aeronave {aeronave_id}\", voo_atual['origem'], voo_atual['destino'], voo_atual['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f\"{voo_atual['tempo']} min\"])\n", + " hora_atual = hora_chegada + datetime.timedelta(minutes=40)\n", + " local_atual = voo_atual['destino']\n", + " \n", + " while True:\n", + " prox_voo = None\n", + " for idx, v in enumerate(voos_para_fazer_c99_6):\n", + " if v['origem'] == local_atual:\n", + " if (hora_atual - datetime.datetime(2025, 1, 1, 0, 0, 0) + datetime.timedelta(minutes=int(v['tempo']))).total_seconds() <= 1440 * 60:\n", + " prox_voo = voos_para_fazer_c99_6.pop(idx)\n", + " break\n", + " if prox_voo:\n", + " tempo_delta = datetime.timedelta(minutes=int(prox_voo['tempo']))\n", + " hora_chegada = hora_atual + tempo_delta\n", + " tabela_horarios_c99_6.append([f\"Aeronave {aeronave_id}\", prox_voo['origem'], prox_voo['destino'], prox_voo['tipo'], hora_atual.strftime('%H:%M'), hora_chegada.strftime('%H:%M'), f\"{prox_voo['tempo']} min\"])\n", + " hora_atual = hora_chegada + datetime.timedelta(minutes=40)\n", + " local_atual = prox_voo['destino']\n", + " else:\n", + " break\n", + " aeronave_id += 1\n", + "\n", + "print(tabulate(tabela_horarios_c99_6, headers=[\"Aeronave\", \"Origem\", \"Destino\", \"Tipo\", \"Partida\", \"Chegada\", \"Duração\"], tablefmt=\"github\"))\n" + ] } ], "metadata": {