Common European Financial Factors in Output-Gap Estimation

# ============================================================
# CELL 1 — Download and transform common European/global factors
# ============================================================
# No files are saved.
#
# Output objects:
#   common_factor_data["factors"]       -> transformed factors, ready for modelling
#   common_factor_data["raw_quarterly"] -> raw quarterly series
#   common_factor_data["daily"]         -> daily Yahoo series
#   common_factor_data["monthly"]       -> monthly FRED series
#   common_factor_data["ecb"]           -> ECB CISS daily series
#
# Convenience object:
#   common_factors = common_factor_data["factors"]

import warnings
warnings.filterwarnings("ignore")

import io
import contextlib
import numpy as np
import pandas as pd
import requests
import yfinance as yf
from io import StringIO
from IPython.display import display


# ============================================================
# 0. Settings
# ============================================================

DOWNLOAD_START_DATE = "1994-01-01"
FINAL_START_DATE = "1995-01-01"
FINAL_START_QUARTER = "1995Q1"
END_DATE = None

EURUSD_TICKER = "EURUSD=X"
EUROSTOXX_TICKER = "^STOXX50E"

FRED_SERIES = {
    "brent_oil": "MCOILBRENTEU",
    "ea_3m_interbank_rate": "IR3TIB01EZQ156N",
    "ea_share_price_index": "SPASTT01EZQ661N",
    "ea_reer": "RBXMBIS",
    "ea_m3_yoy_growth": "EA19MABMM301GYSAQ",
}

UNEMPLOYMENT_SERIES_ID = "LRHUTTTTEZM156S"

CISS_FLOW = "CISS"
CISS_KEYS_TO_TRY = [
    "D.U2.Z0Z.4F.EC.SS_CIN.IDX",
    "D.U2.Z0Z.4F.EC.SS_CI.IDX",
]


# ============================================================
# 1. Helpers
# ============================================================

def standardize(s):
    s = pd.Series(s, dtype=float)
    sd = s.std()
    if not np.isfinite(sd) or sd == 0:
        return s - s.mean()
    return (s - s.mean()) / sd


def dlog100(s):
    s = pd.Series(s, dtype=float)
    return 100.0 * np.log(s).diff()


def trim_start(df, start_quarter=FINAL_START_QUARTER):
    start = pd.Period(start_quarter, freq="Q")
    return df.loc[df.index >= start].copy()


def to_quarter_period_index(dates):
    return pd.to_datetime(dates).to_period("Q")


def quarterly_resample_last(s):
    try:
        out = s.resample("QE").last()
    except Exception:
        out = s.resample("Q").last()
    out.index = out.index.to_period("Q")
    return out


def quarterly_resample_mean(s):
    try:
        out = s.resample("QE").mean()
    except Exception:
        out = s.resample("Q").mean()
    out.index = out.index.to_period("Q")
    return out


def quarterly_resample_max(s):
    try:
        out = s.resample("QE").max()
    except Exception:
        out = s.resample("Q").max()
    out.index = out.index.to_period("Q")
    return out


def download_yahoo_series(ticker, start, end=None, value_name="value"):
    df = yf.download(
        ticker,
        start=start,
        end=end,
        progress=False,
        auto_adjust=False
    )

    if df.empty:
        raise ValueError(f"Could not download Yahoo Finance data: {ticker}")

    if isinstance(df.columns, pd.MultiIndex):
        df.columns = df.columns.get_level_values(0)

    if "Adj Close" in df.columns:
        s = df["Adj Close"].copy()
    elif "Close" in df.columns:
        s = df["Close"].copy()
    else:
        raise ValueError(f"No Close or Adj Close column for ticker: {ticker}")

    s.index = pd.to_datetime(s.index).tz_localize(None)
    s = pd.to_numeric(s, errors="coerce").dropna()
    s.name = value_name

    return s


def make_quarterly_log_change_from_daily(daily_series, level_name, dlog_name):
    q_level = quarterly_resample_last(daily_series)
    q_dlog = 100.0 * np.log(q_level).diff()

    out = pd.DataFrame({
        level_name: q_level,
        dlog_name: q_dlog,
        dlog_name.replace("_dlog", "_pct_change"): 100.0 * q_level.pct_change(),
    })

    out.index.name = "quarter"
    return out


def download_fred_series(series_id):
    url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={series_id}"

    df = pd.read_csv(url)

    if "observation_date" in df.columns:
        date_col = "observation_date"
    elif "DATE" in df.columns:
        date_col = "DATE"
    else:
        date_col = df.columns[0]

    if series_id in df.columns:
        value_col = series_id
    else:
        value_col = [c for c in df.columns if c != date_col][0]

    df = df.rename(columns={date_col: "date", value_col: "value"})

    df["date"] = pd.to_datetime(df["date"], errors="coerce")
    df["value"] = pd.to_numeric(df["value"], errors="coerce")

    df = df.dropna(subset=["date", "value"])
    df = df[df["date"] >= pd.Timestamp(DOWNLOAD_START_DATE)]
    df = df.sort_values("date")

    if df.empty:
        raise ValueError(f"No numeric observations downloaded for FRED series {series_id}")

    return df


def monthly_to_quarterly_mean(monthly_df, name):
    df = monthly_df.copy()
    df = df.set_index("date").sort_index()

    try:
        q = df["value"].resample("QE").mean()
    except Exception:
        q = df["value"].resample("Q").mean()

    q.index = q.index.to_period("Q")
    q.name = name

    return q


def monthly_to_quarterly_unemployment(monthly_df):
    df = monthly_df.copy()
    df = df[df["date"] >= pd.Timestamp(FINAL_START_DATE)]
    df = df.set_index("date").sort_index()

    try:
        q_rate = df["value"].resample("QE").mean()
    except Exception:
        q_rate = df["value"].resample("Q").mean()

    q_rate.index = q_rate.index.to_period("Q")

    out = pd.DataFrame(index=q_rate.index)
    out["ea_unemployment_rate"] = q_rate
    out["ea_unemployment_change"] = q_rate.diff()
    out["ea_unemployment_std"] = standardize(q_rate)

    out = out.loc[out.index >= pd.Period(FINAL_START_QUARTER, freq="Q")]

    return out


def ecb_download_csv(flow, key, start_date=DOWNLOAD_START_DATE):
    url = (
        f"https://data-api.ecb.europa.eu/service/data/{flow}/{key}"
        f"?startPeriod={start_date}&format=csvdata"
    )

    r = requests.get(url, timeout=60)
    r.raise_for_status()

    df = pd.read_csv(StringIO(r.text))

    if "TIME_PERIOD" not in df.columns or "OBS_VALUE" not in df.columns:
        raise ValueError(f"Unexpected ECB CSV format. Columns: {df.columns.tolist()}")

    df["TIME_PERIOD"] = pd.to_datetime(df["TIME_PERIOD"], errors="coerce")
    df["OBS_VALUE"] = pd.to_numeric(df["OBS_VALUE"], errors="coerce")

    s = (
        df.dropna(subset=["TIME_PERIOD", "OBS_VALUE"])
          .set_index("TIME_PERIOD")["OBS_VALUE"]
          .sort_index()
    )

    s.name = "ciss"
    return s


def download_ciss():
    last_error = None

    for key in CISS_KEYS_TO_TRY:
        try:
            s = ecb_download_csv(CISS_FLOW, key)
            q_mean = quarterly_resample_mean(s)
            q_max = quarterly_resample_max(s)

            q_mean.name = "ciss_mean"
            q_max.name = "ciss_max"

            return s, q_mean, q_max

        except Exception as e:
            last_error = e

    raise RuntimeError(f"Could not download CISS. Last error: {last_error}")


# ============================================================
# 2. Main download and transformation
# ============================================================

with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):

    # ----------------------------
    # Yahoo Finance
    # ----------------------------

    eurusd_daily = download_yahoo_series(
        ticker=EURUSD_TICKER,
        start=DOWNLOAD_START_DATE,
        end=END_DATE,
        value_name="eurusd"
    )

    eurostoxx_daily = download_yahoo_series(
        ticker=EUROSTOXX_TICKER,
        start=DOWNLOAD_START_DATE,
        end=END_DATE,
        value_name="eurostoxx50"
    )

    eurusd_q = make_quarterly_log_change_from_daily(
        daily_series=eurusd_daily,
        level_name="eurusd",
        dlog_name="eurusd_dlog"
    )

    eurostoxx_q = make_quarterly_log_change_from_daily(
        daily_series=eurostoxx_daily,
        level_name="eurostoxx50",
        dlog_name="eurostoxx50_dlog"
    )

    # ----------------------------
    # FRED monthly/quarterly series
    # ----------------------------

    fred_quarterly = {}
    fred_monthly = {}

    for name, sid in FRED_SERIES.items():
        monthly_df = download_fred_series(sid)
        fred_monthly[name] = monthly_df
        fred_quarterly[name] = monthly_to_quarterly_mean(monthly_df, name)

    unemployment_monthly = download_fred_series(UNEMPLOYMENT_SERIES_ID)
    unemployment_q = monthly_to_quarterly_unemployment(unemployment_monthly)

    # ----------------------------
    # ECB CISS
    # ----------------------------

    ciss_daily, ciss_mean_q, ciss_max_q = download_ciss()

    # ----------------------------
    # Raw quarterly dataset
    # ----------------------------

    raw_q = pd.concat(
        [
            eurusd_q,
            eurostoxx_q,
            ciss_mean_q,
            ciss_max_q,
            fred_quarterly["brent_oil"],
            fred_quarterly["ea_3m_interbank_rate"],
            fred_quarterly["ea_share_price_index"],
            fred_quarterly["ea_reer"],
            fred_quarterly["ea_m3_yoy_growth"],
            unemployment_q,
        ],
        axis=1
    ).sort_index()

    raw_q = trim_start(raw_q, FINAL_START_QUARTER)

    # ----------------------------
    # Transformed modelling factors
    # ----------------------------

    factors = pd.DataFrame(index=raw_q.index)

    factors["eurusd_dlog"] = raw_q["eurusd_dlog"]

    factors["eurstock_logreturn"] = raw_q["eurostoxx50_dlog"]
    factors["eurostoxx50_dlog"] = raw_q["eurostoxx50_dlog"]

    factors["ciss_std"] = standardize(raw_q["ciss_mean"])
    factors["ciss_max_std"] = standardize(raw_q["ciss_max"])

    factors["brent_dlog"] = dlog100(raw_q["brent_oil"])
    factors["ea_3m_rate_change"] = raw_q["ea_3m_interbank_rate"].diff()
    factors["ea_share_price_dlog"] = dlog100(raw_q["ea_share_price_index"])
    factors["ea_reer_dlog"] = dlog100(raw_q["ea_reer"])

    factors["ea_m3_yoy_std"] = standardize(raw_q["ea_m3_yoy_growth"])
    factors["ea_m3_yoy_change"] = raw_q["ea_m3_yoy_growth"].diff()

    factors["ea_unemployment_rate"] = raw_q["ea_unemployment_rate"]
    factors["ea_unemployment_change"] = raw_q["ea_unemployment_change"]
    factors["ea_unemployment_std"] = raw_q["ea_unemployment_std"]

    factors = trim_start(factors, FINAL_START_QUARTER)

    # ----------------------------
    # Final object
    # ----------------------------

    common_factor_data = {
        "factors": factors,
        "raw_quarterly": raw_q,
        "daily": {
            "eurusd": eurusd_daily,
            "eurostoxx50": eurostoxx_daily,
        },
        "monthly": {
            **fred_monthly,
            "unemployment": unemployment_monthly,
        },
        "ecb": {
            "ciss_daily": ciss_daily,
        },
        "settings": {
            "download_start_date": DOWNLOAD_START_DATE,
            "final_start_date": FINAL_START_DATE,
            "final_start_quarter": FINAL_START_QUARTER,
            "eurusd_ticker": EURUSD_TICKER,
            "eurostoxx_ticker": EUROSTOXX_TICKER,
            "fred_series": FRED_SERIES,
            "unemployment_series_id": UNEMPLOYMENT_SERIES_ID,
            "ciss_flow": CISS_FLOW,
            "ciss_keys_to_try": CISS_KEYS_TO_TRY,
        }
    }

    common_factors = common_factor_data["factors"]


print("\nTransformed factors tail:")
display(common_factors.tail(15))

# ============================================================
# CELL 2 — Estimate selected factor models with fixed lambda2
# ============================================================
# Assumption:
#   The previous cell has already created `common_factors`
#   or `common_factor_data["factors"]`.
#
# This cell:
#   - reads country GDP data from Excel, as before;
#   - uses common factors from the existing notebook object, not from Excel;
#   - uses hard-coded lambda2 values selected in a previous optimization step;
#   - estimates the baseline-same-sample and factor models with fixed lambda2;
#   - shows a progress bar during estimation;
#   - prints only the FINAL FACTOR RESULTS table.
#
# Output objects:
#   summary_df
#   factor_results
#   baseline_results
#   outputs_long
#   failed_df
#   eurostoxx_potential_output
#   eurostoxx_potential_output_long

import warnings
warnings.filterwarnings("ignore")

import re
from pathlib import Path

import numpy as np
import pandas as pd

from scipy.optimize import minimize
from scipy.stats import gamma as gamma_dist
from scipy.stats import norm, chi2
from statsmodels.tsa.filters.hp_filter import hpfilter
from statsmodels.tsa.statespace.mlemodel import MLEModel

try:
    from tqdm.auto import tqdm
except Exception:
    tqdm = None


# ============================================================
# 0. SETTINGS
# ============================================================

GDP_EXCEL = "real_sa_gdp_complete_from_1995_all_available_countries.xlsx"

START_QUARTER = "1995Q1"
END_QUARTER = "2025Q4"

COUNTRIES = None

USE_PRIORS = True
STANDARDIZE_FACTORS = True

BETA_UPPER = 2

BETA_PRIOR_MEAN = 0.70
BETA_PRIOR_SD = 0.30

HP_LAMBDA = 1600

MIN_OBS = 25

# This is the factor whose potential-output estimate is stored together
# with the corresponding same-sample baseline potential output.
EUROSTOXX_FACTOR_ID = "eurstock_logreturn"


# ============================================================
# 1. FINAL FACTOR-LAG CHOICES
# ============================================================

FACTOR_SPECS = [
    {
        "factor_id": "eurusd_dlog",
        "lag": 2,
        "description": "EUR/USD quarterly exchange-rate log change",
        "aliases": [
            "eurusd_dlog",
            "eur_usd_dlog",
            "eurusd_log_change",
            "eurusd_change",
            "eur_usd_change",
        ],
    },
    {
        "factor_id": "ea_share_price_dlog",
        "lag": 2,
        "description": "Euro area share price index quarterly log return",
        "aliases": [
            "ea_share_price_dlog",
        ],
    },
    {
        "factor_id": "eurstock_logreturn",
        "lag": 0,
        "description": "European stock index quarterly log return",
        "aliases": [
            "eurstock_logreturn",
            "eurstock_dlog",
            "eurostoxx50_dlog",
            "eurostoxx_dlog",
            "eu_stock_dlog",
            "europe_stock_dlog",
        ],
    },
    {
        "factor_id": "ea_unemployment_std",
        "lag": 0,
        "description": "Euro area unemployment rate, standardized",
        "aliases": [
            "ea_unemployment_std",
            "ea19_unemployment_std",
            "ea20_unemployment_std",
            "euro_area_unemployment_std",
        ],
    },
    {
        "factor_id": "ciss_std",
        "lag": 0,
        "description": "ECB CISS, standardized",
        "aliases": [
            "ciss_std",
        ],
    },
    {
        "factor_id": "brent_dlog",
        "lag": 0,
        "description": "Brent oil price quarterly log change",
        "aliases": [
            "brent_dlog",
        ],
    },
    {
        "factor_id": "ea_3m_rate_change",
        "lag": 0,
        "description": "Euro area 3M rate quarterly change",
        "aliases": [
            "ea_3m_rate_change",
        ],
    },
]


# ============================================================
# 2. QUARTER HANDLING
# ============================================================

def parse_quarter(x):
    if isinstance(x, pd.Period):
        return x.asfreq("Q")

    if isinstance(x, pd.Timestamp):
        return x.to_period("Q")

    s = str(x).strip()

    m = re.match(r"^(\d{4})-?Q([1-4])$", s)
    if m:
        return pd.Period(f"{m.group(1)}Q{m.group(2)}", freq="Q")

    try:
        return pd.Timestamp(s).to_period("Q")
    except Exception:
        raise ValueError(f"Nem értelmezhető negyedév: {x}")


def make_period_index(df):
    df = df.copy()

    possible_qcols = [
        c for c in df.columns
        if str(c).lower() in ["quarter", "date", "time", "period"]
    ]

    qcol = possible_qcols[0] if len(possible_qcols) > 0 else df.columns[0]

    df = df.rename(columns={qcol: "quarter"})
    df["quarter"] = df["quarter"].apply(parse_quarter)
    df = df.set_index("quarter").sort_index()

    for col in df.columns:
        df[col] = pd.to_numeric(df[col], errors="coerce")

    return df


def ensure_quarter_index(df):
    df = df.copy()

    if isinstance(df.index, pd.PeriodIndex):
        df.index = df.index.asfreq("Q")
    elif isinstance(df.index, pd.DatetimeIndex):
        df.index = df.index.to_period("Q")
    elif "quarter" in df.columns:
        df["quarter"] = df["quarter"].apply(parse_quarter)
        df = df.set_index("quarter")
    else:
        df.index = [parse_quarter(x) for x in df.index]

    df = df.sort_index()

    for col in df.columns:
        df[col] = pd.to_numeric(df[col], errors="coerce")

    return df


def cut_sample(df):
    return df.loc[
        (df.index >= pd.Period(START_QUARTER, freq="Q")) &
        (df.index <= pd.Period(END_QUARTER, freq="Q"))
    ].copy()


def read_quarterly_excel(path, sheet_candidates=None):
    path = Path(path)

    if not path.exists():
        raise FileNotFoundError(f"Missing file: {path}")

    xls = pd.ExcelFile(path)

    if sheet_candidates is None:
        sheet_candidates = []

    chosen_sheet = None

    for sh in sheet_candidates:
        if sh in xls.sheet_names:
            chosen_sheet = sh
            break

    if chosen_sheet is None:
        chosen_sheet = xls.sheet_names[0]

    df = pd.read_excel(path, sheet_name=chosen_sheet)
    df = make_period_index(df)
    df = cut_sample(df)

    return df


def get_factors_from_existing_object():
    if "common_factors" in globals():
        factors = common_factors.copy()
    elif "common_factor_data" in globals() and "factors" in common_factor_data:
        factors = common_factor_data["factors"].copy()
    else:
        raise NameError(
            "Nem találom a `common_factors` objektumot. "
            "Előbb futtasd le a közös faktorokat letöltő cellát."
        )

    factors = ensure_quarter_index(factors)
    factors = cut_sample(factors)

    return factors


def find_column(df, aliases):
    lower_map = {str(c).lower(): c for c in df.columns}

    for a in aliases:
        if a.lower() in lower_map:
            return lower_map[a.lower()]

    raise KeyError(
        f"Egyik alias sem található: {aliases}. "
        f"Elérhető oszlopok: {df.columns.tolist()}"
    )


# ============================================================
# 3. FIXED LAMBDA2 VALUES
# ============================================================
# These values were selected in a previous lambda2 optimization step
# and are hard-coded here to avoid re-reading the Excel file during estimation.

FIXED_LAMBDA2 = {
    ('Belgium', 'baseline_same_sample', 'eurusd_dlog', 2): 507.173411693,
    ('Belgium', 'factor', 'eurusd_dlog', 2): 492.486777172,
    ('Belgium', 'baseline_same_sample', 'ea_share_price_dlog', 2): 854.241235121,
    ('Belgium', 'factor', 'ea_share_price_dlog', 2): 946.087001125,
    ('Belgium', 'baseline_same_sample', 'eurstock_logreturn', 0): 457.108029957,
    ('Belgium', 'factor', 'eurstock_logreturn', 0): 314.667555053,
    ('Belgium', 'baseline_same_sample', 'ea_unemployment_std', 0): 889.252366917,
    ('Belgium', 'factor', 'ea_unemployment_std', 0): 845.370674413,
    ('Belgium', 'baseline_same_sample', 'ciss_std', 0): 867.755081688,
    ('Belgium', 'factor', 'ciss_std', 0): 895.008842094,
    ('Belgium', 'baseline_same_sample', 'brent_dlog', 0): 867.755081688,
    ('Belgium', 'factor', 'brent_dlog', 0): 904.54127239,
    ('Belgium', 'baseline_same_sample', 'ea_3m_rate_change', 0): 867.755081688,
    ('Belgium', 'factor', 'ea_3m_rate_change', 0): 1046.53445263,
    ('Czechia', 'baseline_same_sample', 'eurusd_dlog', 2): 44.8477218791,
    ('Czechia', 'factor', 'eurusd_dlog', 2): 50.9261239781,
    ('Czechia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 63.8108970858,
    ('Czechia', 'factor', 'ea_share_price_dlog', 2): 61.519245693,
    ('Czechia', 'baseline_same_sample', 'eurstock_logreturn', 0): 121.378424293,
    ('Czechia', 'factor', 'eurstock_logreturn', 0): 68.8625627266,
    ('Czechia', 'baseline_same_sample', 'ea_unemployment_std', 0): 58.5208433557,
    ('Czechia', 'factor', 'ea_unemployment_std', 0): 11.7047855624,
    ('Czechia', 'baseline_same_sample', 'ciss_std', 0): 57.4456587304,
    ('Czechia', 'factor', 'ciss_std', 0): 31.5871667558,
    ('Czechia', 'baseline_same_sample', 'brent_dlog', 0): 57.4456587304,
    ('Czechia', 'factor', 'brent_dlog', 0): 55.2683152809,
    ('Czechia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 57.4456587304,
    ('Czechia', 'factor', 'ea_3m_rate_change', 0): 56.0026127449,
    ('Denmark', 'baseline_same_sample', 'eurusd_dlog', 2): 109.819715976,
    ('Denmark', 'factor', 'eurusd_dlog', 2): 111.558576352,
    ('Denmark', 'baseline_same_sample', 'ea_share_price_dlog', 2): 153.852456025,
    ('Denmark', 'factor', 'ea_share_price_dlog', 2): 163.017744936,
    ('Denmark', 'baseline_same_sample', 'eurstock_logreturn', 0): 255.99078417,
    ('Denmark', 'factor', 'eurstock_logreturn', 0): 162.224307989,
    ('Denmark', 'baseline_same_sample', 'ea_unemployment_std', 0): 195.397378471,
    ('Denmark', 'factor', 'ea_unemployment_std', 0): 90.933086269,
    ('Denmark', 'baseline_same_sample', 'ciss_std', 0): 191.879335637,
    ('Denmark', 'factor', 'ciss_std', 0): 140.792885273,
    ('Denmark', 'baseline_same_sample', 'brent_dlog', 0): 191.879335637,
    ('Denmark', 'factor', 'brent_dlog', 0): 205.536413104,
    ('Denmark', 'baseline_same_sample', 'ea_3m_rate_change', 0): 191.879335637,
    ('Denmark', 'factor', 'ea_3m_rate_change', 0): 221.619796202,
    ('Germany', 'baseline_same_sample', 'eurusd_dlog', 2): 202.813089788,
    ('Germany', 'factor', 'eurusd_dlog', 2): 208.806203016,
    ('Germany', 'baseline_same_sample', 'ea_share_price_dlog', 2): 247.626263816,
    ('Germany', 'factor', 'ea_share_price_dlog', 2): 224.185858665,
    ('Germany', 'baseline_same_sample', 'eurstock_logreturn', 0): 254.830770689,
    ('Germany', 'factor', 'eurstock_logreturn', 0): 111.596794376,
    ('Germany', 'baseline_same_sample', 'ea_unemployment_std', 0): 244.256734416,
    ('Germany', 'factor', 'ea_unemployment_std', 0): 173.608462663,
    ('Germany', 'baseline_same_sample', 'ciss_std', 0): 256.202100153,
    ('Germany', 'factor', 'ciss_std', 0): 223.091068625,
    ('Germany', 'baseline_same_sample', 'brent_dlog', 0): 256.202100153,
    ('Germany', 'factor', 'brent_dlog', 0): 278.237664892,
    ('Germany', 'baseline_same_sample', 'ea_3m_rate_change', 0): 256.202100153,
    ('Germany', 'factor', 'ea_3m_rate_change', 0): 312.18151094,
    ('Estonia', 'baseline_same_sample', 'eurusd_dlog', 2): 72.5117050858,
    ('Estonia', 'factor', 'eurusd_dlog', 2): 69.5136216988,
    ('Estonia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 48.3376837094,
    ('Estonia', 'factor', 'ea_share_price_dlog', 2): 59.5766089548,
    ('Estonia', 'baseline_same_sample', 'eurstock_logreturn', 0): 59.3250678735,
    ('Estonia', 'factor', 'eurstock_logreturn', 0): 33.8852968149,
    ('Estonia', 'baseline_same_sample', 'ea_unemployment_std', 0): 64.6979267929,
    ('Estonia', 'factor', 'ea_unemployment_std', 0): 12.9402673457,
    ('Estonia', 'baseline_same_sample', 'ciss_std', 0): 63.0514032078,
    ('Estonia', 'factor', 'ciss_std', 0): 35.2605209738,
    ('Estonia', 'baseline_same_sample', 'brent_dlog', 0): 63.0514032078,
    ('Estonia', 'factor', 'brent_dlog', 0): 61.9124566502,
    ('Estonia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 63.0514032078,
    ('Estonia', 'factor', 'ea_3m_rate_change', 0): 69.6290211243,
    ('Ireland', 'baseline_same_sample', 'eurusd_dlog', 2): 85.8884321046,
    ('Ireland', 'factor', 'eurusd_dlog', 2): 83.8172238123,
    ('Ireland', 'baseline_same_sample', 'ea_share_price_dlog', 2): 85.359077027,
    ('Ireland', 'factor', 'ea_share_price_dlog', 2): 90.1806828354,
    ('Ireland', 'baseline_same_sample', 'eurstock_logreturn', 0): 156.934341982,
    ('Ireland', 'factor', 'eurstock_logreturn', 0): 141.640056959,
    ('Ireland', 'baseline_same_sample', 'ea_unemployment_std', 0): 119.813859295,
    ('Ireland', 'factor', 'ea_unemployment_std', 0): 52.7198939955,
    ('Ireland', 'baseline_same_sample', 'ciss_std', 0): 109.089146513,
    ('Ireland', 'factor', 'ciss_std', 0): 76.8779015035,
    ('Ireland', 'baseline_same_sample', 'brent_dlog', 0): 109.089146513,
    ('Ireland', 'factor', 'brent_dlog', 0): 87.3254816969,
    ('Ireland', 'baseline_same_sample', 'ea_3m_rate_change', 0): 109.089146513,
    ('Ireland', 'factor', 'ea_3m_rate_change', 0): 79.3171187853,
    ('Greece', 'baseline_same_sample', 'eurusd_dlog', 2): 52.6842105729,
    ('Greece', 'factor', 'eurusd_dlog', 2): 52.5925002065,
    ('Greece', 'baseline_same_sample', 'ea_share_price_dlog', 2): 57.1777332339,
    ('Greece', 'factor', 'ea_share_price_dlog', 2): 57.6479431878,
    ('Greece', 'baseline_same_sample', 'eurstock_logreturn', 0): 108.167027035,
    ('Greece', 'factor', 'eurstock_logreturn', 0): 54.836020821,
    ('Greece', 'baseline_same_sample', 'ea_unemployment_std', 0): 58.1639617645,
    ('Greece', 'factor', 'ea_unemployment_std', 0): 49.3883562494,
    ('Greece', 'baseline_same_sample', 'ciss_std', 0): 56.7496187441,
    ('Greece', 'factor', 'ciss_std', 0): 28.5508229156,
    ('Greece', 'baseline_same_sample', 'brent_dlog', 0): 56.7496187441,
    ('Greece', 'factor', 'brent_dlog', 0): 56.7574022754,
    ('Greece', 'baseline_same_sample', 'ea_3m_rate_change', 0): 56.7496187441,
    ('Greece', 'factor', 'ea_3m_rate_change', 0): 56.7032552071,
    ('Spain', 'baseline_same_sample', 'eurusd_dlog', 2): 146.471524172,
    ('Spain', 'factor', 'eurusd_dlog', 2): 142.572595005,
    ('Spain', 'baseline_same_sample', 'ea_share_price_dlog', 2): 217.890005146,
    ('Spain', 'factor', 'ea_share_price_dlog', 2): 207.930703635,
    ('Spain', 'baseline_same_sample', 'eurstock_logreturn', 0): 239.460126109,
    ('Spain', 'factor', 'eurstock_logreturn', 0): 151.056918536,
    ('Spain', 'baseline_same_sample', 'ea_unemployment_std', 0): 246.057503934,
    ('Spain', 'factor', 'ea_unemployment_std', 0): 216.577462158,
    ('Spain', 'baseline_same_sample', 'ciss_std', 0): 217.559265102,
    ('Spain', 'factor', 'ciss_std', 0): 202.430956814,
    ('Spain', 'baseline_same_sample', 'brent_dlog', 0): 217.559265102,
    ('Spain', 'factor', 'brent_dlog', 0): 223.927414367,
    ('Spain', 'baseline_same_sample', 'ea_3m_rate_change', 0): 217.559265102,
    ('Spain', 'factor', 'ea_3m_rate_change', 0): 223.323842357,
    ('France', 'baseline_same_sample', 'eurusd_dlog', 2): 381.952894897,
    ('France', 'factor', 'eurusd_dlog', 2): 375.519272565,
    ('France', 'baseline_same_sample', 'ea_share_price_dlog', 2): 1235.33298636,
    ('France', 'factor', 'ea_share_price_dlog', 2): 1306.79208404,
    ('France', 'baseline_same_sample', 'eurstock_logreturn', 0): 400.641160069,
    ('France', 'factor', 'eurstock_logreturn', 0): 285.687838468,
    ('France', 'baseline_same_sample', 'ea_unemployment_std', 0): 1469.43471432,
    ('France', 'factor', 'ea_unemployment_std', 0): 1375.03886927,
    ('France', 'baseline_same_sample', 'ciss_std', 0): 1408.74028895,
    ('France', 'factor', 'ciss_std', 0): 1458.67463425,
    ('France', 'baseline_same_sample', 'brent_dlog', 0): 1408.74028895,
    ('France', 'factor', 'brent_dlog', 0): 1377.45336846,
    ('France', 'baseline_same_sample', 'ea_3m_rate_change', 0): 1408.74028895,
    ('France', 'factor', 'ea_3m_rate_change', 0): 1638.06142747,
    ('Croatia', 'baseline_same_sample', 'eurusd_dlog', 2): 73.8852350533,
    ('Croatia', 'factor', 'eurusd_dlog', 2): 74.8886524676,
    ('Croatia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 54.0968650362,
    ('Croatia', 'factor', 'ea_share_price_dlog', 2): 43.7788636589,
    ('Croatia', 'baseline_same_sample', 'eurstock_logreturn', 0): 339.011974431,
    ('Croatia', 'factor', 'eurstock_logreturn', 0): 103.557484297,
    ('Croatia', 'baseline_same_sample', 'ea_unemployment_std', 0): 111.724239101,
    ('Croatia', 'factor', 'ea_unemployment_std', 0): 119.949963786,
    ('Croatia', 'baseline_same_sample', 'ciss_std', 0): 108.100108766,
    ('Croatia', 'factor', 'ciss_std', 0): 83.9602807023,
    ('Croatia', 'baseline_same_sample', 'brent_dlog', 0): 108.100108766,
    ('Croatia', 'factor', 'brent_dlog', 0): 107.910435762,
    ('Croatia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 108.100108766,
    ('Croatia', 'factor', 'ea_3m_rate_change', 0): 107.294051006,
    ('Latvia', 'baseline_same_sample', 'eurusd_dlog', 2): 57.5961974791,
    ('Latvia', 'factor', 'eurusd_dlog', 2): 71.042274873,
    ('Latvia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 56.7549369041,
    ('Latvia', 'factor', 'ea_share_price_dlog', 2): 52.5573690913,
    ('Latvia', 'baseline_same_sample', 'eurstock_logreturn', 0): 54.3662184788,
    ('Latvia', 'factor', 'eurstock_logreturn', 0): 18.0133847833,
    ('Latvia', 'baseline_same_sample', 'ea_unemployment_std', 0): 59.5395323805,
    ('Latvia', 'factor', 'ea_unemployment_std', 0): 11.9085341027,
    ('Latvia', 'baseline_same_sample', 'ciss_std', 0): 59.2492977948,
    ('Latvia', 'factor', 'ciss_std', 0): 26.0196989788,
    ('Latvia', 'baseline_same_sample', 'brent_dlog', 0): 59.2492977948,
    ('Latvia', 'factor', 'brent_dlog', 0): 57.8448875487,
    ('Latvia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 59.2492977948,
    ('Latvia', 'factor', 'ea_3m_rate_change', 0): 59.1388494777,
    ('Lithuania', 'baseline_same_sample', 'eurusd_dlog', 2): 54.2999699375,
    ('Lithuania', 'factor', 'eurusd_dlog', 2): 73.0257910544,
    ('Lithuania', 'baseline_same_sample', 'ea_share_price_dlog', 2): 48.2578439768,
    ('Lithuania', 'factor', 'ea_share_price_dlog', 2): 55.4439564297,
    ('Lithuania', 'baseline_same_sample', 'eurstock_logreturn', 0): 73.0273133694,
    ('Lithuania', 'factor', 'eurstock_logreturn', 0): 58.3012266568,
    ('Lithuania', 'baseline_same_sample', 'ea_unemployment_std', 0): 55.6024389953,
    ('Lithuania', 'factor', 'ea_unemployment_std', 0): 11.1210739347,
    ('Lithuania', 'baseline_same_sample', 'ciss_std', 0): 50.7613671611,
    ('Lithuania', 'factor', 'ciss_std', 0): 19.1312314329,
    ('Lithuania', 'baseline_same_sample', 'brent_dlog', 0): 50.7613671611,
    ('Lithuania', 'factor', 'brent_dlog', 0): 34.8352759488,
    ('Lithuania', 'baseline_same_sample', 'ea_3m_rate_change', 0): 50.7613671611,
    ('Lithuania', 'factor', 'ea_3m_rate_change', 0): 60.3844352596,
    ('Luxembourg', 'baseline_same_sample', 'eurusd_dlog', 2): 153.643175797,
    ('Luxembourg', 'factor', 'eurusd_dlog', 2): 155.451654628,
    ('Luxembourg', 'baseline_same_sample', 'ea_share_price_dlog', 2): 170.850149487,
    ('Luxembourg', 'factor', 'ea_share_price_dlog', 2): 165.021749641,
    ('Luxembourg', 'baseline_same_sample', 'eurstock_logreturn', 0): 385.526870607,
    ('Luxembourg', 'factor', 'eurstock_logreturn', 0): 239.229919947,
    ('Luxembourg', 'baseline_same_sample', 'ea_unemployment_std', 0): 233.129101907,
    ('Luxembourg', 'factor', 'ea_unemployment_std', 0): 77.1723322689,
    ('Luxembourg', 'baseline_same_sample', 'ciss_std', 0): 242.868489641,
    ('Luxembourg', 'factor', 'ciss_std', 0): 244.213445216,
    ('Luxembourg', 'baseline_same_sample', 'brent_dlog', 0): 242.868489641,
    ('Luxembourg', 'factor', 'brent_dlog', 0): 211.2535277,
    ('Luxembourg', 'baseline_same_sample', 'ea_3m_rate_change', 0): 242.868489641,
    ('Luxembourg', 'factor', 'ea_3m_rate_change', 0): 252.584135294,
    ('Hungary', 'baseline_same_sample', 'eurusd_dlog', 2): 146.340758195,
    ('Hungary', 'factor', 'eurusd_dlog', 2): 145.344024047,
    ('Hungary', 'baseline_same_sample', 'ea_share_price_dlog', 2): 259.149824686,
    ('Hungary', 'factor', 'ea_share_price_dlog', 2): 278.935212749,
    ('Hungary', 'baseline_same_sample', 'eurstock_logreturn', 0): 349.181592272,
    ('Hungary', 'factor', 'eurstock_logreturn', 0): 154.16360338,
    ('Hungary', 'baseline_same_sample', 'ea_unemployment_std', 0): 246.434443623,
    ('Hungary', 'factor', 'ea_unemployment_std', 0): 187.861601635,
    ('Hungary', 'baseline_same_sample', 'ciss_std', 0): 235.936561261,
    ('Hungary', 'factor', 'ciss_std', 0): 177.669539869,
    ('Hungary', 'baseline_same_sample', 'brent_dlog', 0): 235.936561261,
    ('Hungary', 'factor', 'brent_dlog', 0): 246.520462996,
    ('Hungary', 'baseline_same_sample', 'ea_3m_rate_change', 0): 235.936561261,
    ('Hungary', 'factor', 'ea_3m_rate_change', 0): 257.347919851,
    ('Austria', 'baseline_same_sample', 'eurusd_dlog', 2): 303.618275521,
    ('Austria', 'factor', 'eurusd_dlog', 2): 289.289735276,
    ('Austria', 'baseline_same_sample', 'ea_share_price_dlog', 2): 688.401573283,
    ('Austria', 'factor', 'ea_share_price_dlog', 2): 662.501443745,
    ('Austria', 'baseline_same_sample', 'eurstock_logreturn', 0): 315.066576389,
    ('Austria', 'factor', 'eurstock_logreturn', 0): 237.382631201,
    ('Austria', 'baseline_same_sample', 'ea_unemployment_std', 0): 548.975431394,
    ('Austria', 'factor', 'ea_unemployment_std', 0): 547.78804898,
    ('Austria', 'baseline_same_sample', 'ciss_std', 0): 693.974908714,
    ('Austria', 'factor', 'ciss_std', 0): 620.075469927,
    ('Austria', 'baseline_same_sample', 'brent_dlog', 0): 693.974908714,
    ('Austria', 'factor', 'brent_dlog', 0): 704.105009776,
    ('Austria', 'baseline_same_sample', 'ea_3m_rate_change', 0): 693.974908714,
    ('Austria', 'factor', 'ea_3m_rate_change', 0): 801.707003556,
    ('Poland', 'baseline_same_sample', 'eurusd_dlog', 2): 79.5714895728,
    ('Poland', 'factor', 'eurusd_dlog', 2): 69.8617475624,
    ('Poland', 'baseline_same_sample', 'ea_share_price_dlog', 2): 99.5425674437,
    ('Poland', 'factor', 'ea_share_price_dlog', 2): 107.385849744,
    ('Poland', 'baseline_same_sample', 'eurstock_logreturn', 0): 294.022626121,
    ('Poland', 'factor', 'eurstock_logreturn', 0): 60.901963806,
    ('Poland', 'baseline_same_sample', 'ea_unemployment_std', 0): 52.2652526835,
    ('Poland', 'factor', 'ea_unemployment_std', 0): 43.7388314118,
    ('Poland', 'baseline_same_sample', 'ciss_std', 0): 52.036437017,
    ('Poland', 'factor', 'ciss_std', 0): 37.3274586767,
    ('Poland', 'baseline_same_sample', 'brent_dlog', 0): 52.036437017,
    ('Poland', 'factor', 'brent_dlog', 0): 56.2414993864,
    ('Poland', 'baseline_same_sample', 'ea_3m_rate_change', 0): 52.036437017,
    ('Poland', 'factor', 'ea_3m_rate_change', 0): 47.9863509301,
    ('Portugal', 'baseline_same_sample', 'eurusd_dlog', 2): 220.430508004,
    ('Portugal', 'factor', 'eurusd_dlog', 2): 211.72186705,
    ('Portugal', 'baseline_same_sample', 'ea_share_price_dlog', 2): 235.083112024,
    ('Portugal', 'factor', 'ea_share_price_dlog', 2): 215.796345833,
    ('Portugal', 'baseline_same_sample', 'eurstock_logreturn', 0): 313.471876132,
    ('Portugal', 'factor', 'eurstock_logreturn', 0): 244.502052552,
    ('Portugal', 'baseline_same_sample', 'ea_unemployment_std', 0): 276.52134625,
    ('Portugal', 'factor', 'ea_unemployment_std', 0): 279.94402073,
    ('Portugal', 'baseline_same_sample', 'ciss_std', 0): 261.086490493,
    ('Portugal', 'factor', 'ciss_std', 0): 253.184508746,
    ('Portugal', 'baseline_same_sample', 'brent_dlog', 0): 261.086490493,
    ('Portugal', 'factor', 'brent_dlog', 0): 267.056141181,
    ('Portugal', 'baseline_same_sample', 'ea_3m_rate_change', 0): 261.086490493,
    ('Portugal', 'factor', 'ea_3m_rate_change', 0): 282.326760531,
    ('Romania', 'baseline_same_sample', 'eurusd_dlog', 2): 87.6373693978,
    ('Romania', 'factor', 'eurusd_dlog', 2): 89.4644296549,
    ('Romania', 'baseline_same_sample', 'ea_share_price_dlog', 2): 181.381374551,
    ('Romania', 'factor', 'ea_share_price_dlog', 2): 187.771656431,
    ('Romania', 'baseline_same_sample', 'eurstock_logreturn', 0): 123.351471252,
    ('Romania', 'factor', 'eurstock_logreturn', 0): 75.5436874814,
    ('Romania', 'baseline_same_sample', 'ea_unemployment_std', 0): 187.922419454,
    ('Romania', 'factor', 'ea_unemployment_std', 0): 71.4629524282,
    ('Romania', 'baseline_same_sample', 'ciss_std', 0): 187.272285097,
    ('Romania', 'factor', 'ciss_std', 0): 163.809816369,
    ('Romania', 'baseline_same_sample', 'brent_dlog', 0): 187.272285097,
    ('Romania', 'factor', 'brent_dlog', 0): 153.251011702,
    ('Romania', 'baseline_same_sample', 'ea_3m_rate_change', 0): 187.272285097,
    ('Romania', 'factor', 'ea_3m_rate_change', 0): 165.578664006,
    ('Slovakia', 'baseline_same_sample', 'eurusd_dlog', 2): 60.3332720135,
    ('Slovakia', 'factor', 'eurusd_dlog', 2): 66.9892095147,
    ('Slovakia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 79.84749151,
    ('Slovakia', 'factor', 'ea_share_price_dlog', 2): 80.3614187785,
    ('Slovakia', 'baseline_same_sample', 'eurstock_logreturn', 0): 1429.32240245,
    ('Slovakia', 'factor', 'eurstock_logreturn', 0): 684.096395112,
    ('Slovakia', 'baseline_same_sample', 'ea_unemployment_std', 0): 84.3351934719,
    ('Slovakia', 'factor', 'ea_unemployment_std', 0): 78.5895941101,
    ('Slovakia', 'baseline_same_sample', 'ciss_std', 0): 83.2956772296,
    ('Slovakia', 'factor', 'ciss_std', 0): 78.8474119006,
    ('Slovakia', 'baseline_same_sample', 'brent_dlog', 0): 83.2956772296,
    ('Slovakia', 'factor', 'brent_dlog', 0): 82.6350418891,
    ('Slovakia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 83.2956772296,
    ('Slovakia', 'factor', 'ea_3m_rate_change', 0): 87.3514461595,
    ('Finland', 'baseline_same_sample', 'eurusd_dlog', 2): 80.1804970156,
    ('Finland', 'factor', 'eurusd_dlog', 2): 80.6167013575,
    ('Finland', 'baseline_same_sample', 'ea_share_price_dlog', 2): 54.6621519046,
    ('Finland', 'factor', 'ea_share_price_dlog', 2): 60.2943976203,
    ('Finland', 'baseline_same_sample', 'eurstock_logreturn', 0): 160.029597158,
    ('Finland', 'factor', 'eurstock_logreturn', 0): 47.3315194147,
    ('Finland', 'baseline_same_sample', 'ea_unemployment_std', 0): 56.3097984012,
    ('Finland', 'factor', 'ea_unemployment_std', 0): 11.2633937616,
    ('Finland', 'baseline_same_sample', 'ciss_std', 0): 53.3654030645,
    ('Finland', 'factor', 'ciss_std', 0): 29.4094866617,
    ('Finland', 'baseline_same_sample', 'brent_dlog', 0): 53.3654030645,
    ('Finland', 'factor', 'brent_dlog', 0): 67.6557893015,
    ('Finland', 'baseline_same_sample', 'ea_3m_rate_change', 0): 53.3654030645,
    ('Finland', 'factor', 'ea_3m_rate_change', 0): 92.1501416174,
    ('Sweden', 'baseline_same_sample', 'eurusd_dlog', 2): 155.1146483,
    ('Sweden', 'factor', 'eurusd_dlog', 2): 154.718536121,
    ('Sweden', 'baseline_same_sample', 'ea_share_price_dlog', 2): 188.914089989,
    ('Sweden', 'factor', 'ea_share_price_dlog', 2): 248.05716248,
    ('Sweden', 'baseline_same_sample', 'eurstock_logreturn', 0): 272.44595378,
    ('Sweden', 'factor', 'eurstock_logreturn', 0): 86.8728918285,
    ('Sweden', 'baseline_same_sample', 'ea_unemployment_std', 0): 269.987920981,
    ('Sweden', 'factor', 'ea_unemployment_std', 0): 72.8068376913,
    ('Sweden', 'baseline_same_sample', 'ciss_std', 0): 272.156640014,
    ('Sweden', 'factor', 'ciss_std', 0): 316.447402016,
    ('Sweden', 'baseline_same_sample', 'brent_dlog', 0): 272.156640014,
    ('Sweden', 'factor', 'brent_dlog', 0): 240.197345262,
    ('Sweden', 'baseline_same_sample', 'ea_3m_rate_change', 0): 272.156640014,
    ('Sweden', 'factor', 'ea_3m_rate_change', 0): 304.414084505,
    ('Iceland', 'baseline_same_sample', 'eurusd_dlog', 2): 86.9017375221,
    ('Iceland', 'factor', 'eurusd_dlog', 2): 87.8076379036,
    ('Iceland', 'baseline_same_sample', 'ea_share_price_dlog', 2): 156.238626888,
    ('Iceland', 'factor', 'ea_share_price_dlog', 2): 150.861126588,
    ('Iceland', 'baseline_same_sample', 'eurstock_logreturn', 0): 197.059175067,
    ('Iceland', 'factor', 'eurstock_logreturn', 0): 169.27180828,
    ('Iceland', 'baseline_same_sample', 'ea_unemployment_std', 0): 150.172852243,
    ('Iceland', 'factor', 'ea_unemployment_std', 0): 165.479088998,
    ('Iceland', 'baseline_same_sample', 'ciss_std', 0): 153.490087927,
    ('Iceland', 'factor', 'ciss_std', 0): 100.588899071,
    ('Iceland', 'baseline_same_sample', 'brent_dlog', 0): 153.490087927,
    ('Iceland', 'factor', 'brent_dlog', 0): 148.982052877,
    ('Iceland', 'baseline_same_sample', 'ea_3m_rate_change', 0): 153.490087927,
    ('Iceland', 'factor', 'ea_3m_rate_change', 0): 165.207919677,
    ('Norway', 'baseline_same_sample', 'eurusd_dlog', 2): 99.2681284441,
    ('Norway', 'factor', 'eurusd_dlog', 2): 95.0290546232,
    ('Norway', 'baseline_same_sample', 'ea_share_price_dlog', 2): 84.5933817038,
    ('Norway', 'factor', 'ea_share_price_dlog', 2): 92.9505827776,
    ('Norway', 'baseline_same_sample', 'eurstock_logreturn', 0): 292.753963586,
    ('Norway', 'factor', 'eurstock_logreturn', 0): 192.072006107,
    ('Norway', 'baseline_same_sample', 'ea_unemployment_std', 0): 68.3575022266,
    ('Norway', 'factor', 'ea_unemployment_std', 0): 49.541923961,
    ('Norway', 'baseline_same_sample', 'ciss_std', 0): 72.7884401877,
    ('Norway', 'factor', 'ciss_std', 0): 76.3213150771,
    ('Norway', 'baseline_same_sample', 'brent_dlog', 0): 72.7884401877,
    ('Norway', 'factor', 'brent_dlog', 0): 66.8526850819,
    ('Norway', 'baseline_same_sample', 'ea_3m_rate_change', 0): 72.7884401877,
    ('Norway', 'factor', 'ea_3m_rate_change', 0): 81.5107240897,
    ('Switzerland', 'baseline_same_sample', 'eurusd_dlog', 2): 79.3979581788,
    ('Switzerland', 'factor', 'eurusd_dlog', 2): 97.7938752074,
    ('Switzerland', 'baseline_same_sample', 'ea_share_price_dlog', 2): 179.836926262,
    ('Switzerland', 'factor', 'ea_share_price_dlog', 2): 157.438317146,
    ('Switzerland', 'baseline_same_sample', 'eurstock_logreturn', 0): 945.408564516,
    ('Switzerland', 'factor', 'eurstock_logreturn', 0): 640.691899752,
    ('Switzerland', 'baseline_same_sample', 'ea_unemployment_std', 0): 168.323173776,
    ('Switzerland', 'factor', 'ea_unemployment_std', 0): 152.625474143,
    ('Switzerland', 'baseline_same_sample', 'ciss_std', 0): 180.311066577,
    ('Switzerland', 'factor', 'ciss_std', 0): 172.950864264,
    ('Switzerland', 'baseline_same_sample', 'brent_dlog', 0): 180.311066577,
    ('Switzerland', 'factor', 'brent_dlog', 0): 177.497828233,
    ('Switzerland', 'baseline_same_sample', 'ea_3m_rate_change', 0): 180.311066577,
    ('Switzerland', 'factor', 'ea_3m_rate_change', 0): 186.793088539,
    ('Serbia', 'baseline_same_sample', 'eurusd_dlog', 2): 86.8446404726,
    ('Serbia', 'factor', 'eurusd_dlog', 2): 90.1619998022,
    ('Serbia', 'baseline_same_sample', 'ea_share_price_dlog', 2): 199.834552548,
    ('Serbia', 'factor', 'ea_share_price_dlog', 2): 201.5219784,
    ('Serbia', 'baseline_same_sample', 'eurstock_logreturn', 0): 226.522950413,
    ('Serbia', 'factor', 'eurstock_logreturn', 0): 144.02255649,
    ('Serbia', 'baseline_same_sample', 'ea_unemployment_std', 0): 292.277799652,
    ('Serbia', 'factor', 'ea_unemployment_std', 0): 274.457570337,
    ('Serbia', 'baseline_same_sample', 'ciss_std', 0): 292.766928907,
    ('Serbia', 'factor', 'ciss_std', 0): 312.796180818,
    ('Serbia', 'baseline_same_sample', 'brent_dlog', 0): 292.766928907,
    ('Serbia', 'factor', 'brent_dlog', 0): 280.751075397,
    ('Serbia', 'baseline_same_sample', 'ea_3m_rate_change', 0): 292.766928907,
    ('Serbia', 'factor', 'ea_3m_rate_change', 0): 292.639402413,
    ('Türkiye', 'baseline_same_sample', 'eurusd_dlog', 2): 131.728103997,
    ('Türkiye', 'factor', 'eurusd_dlog', 2): 132.085152496,
    ('Türkiye', 'baseline_same_sample', 'ea_share_price_dlog', 2): 88.5304472859,
    ('Türkiye', 'factor', 'ea_share_price_dlog', 2): 94.4914082755,
    ('Türkiye', 'baseline_same_sample', 'eurstock_logreturn', 0): 486.2356832,
    ('Türkiye', 'factor', 'eurstock_logreturn', 0): 262.419485925,
    ('Türkiye', 'baseline_same_sample', 'ea_unemployment_std', 0): 79.6893068034,
    ('Türkiye', 'factor', 'ea_unemployment_std', 0): 30.6663054082,
    ('Türkiye', 'baseline_same_sample', 'ciss_std', 0): 80.4575090559,
    ('Türkiye', 'factor', 'ciss_std', 0): 78.1869155856,
    ('Türkiye', 'baseline_same_sample', 'brent_dlog', 0): 80.4575090559,
    ('Türkiye', 'factor', 'brent_dlog', 0): 81.4840196773,
    ('Türkiye', 'baseline_same_sample', 'ea_3m_rate_change', 0): 80.4575090559,
    ('Türkiye', 'factor', 'ea_3m_rate_change', 0): 87.1369857944,
}


def get_fixed_lambda(country, model_type, factor_id, lag):
    key = (str(country), str(model_type), str(factor_id), int(lag))

    if key not in FIXED_LAMBDA2:
        raise KeyError(
            f"No hard-coded lambda2 found for "
            f"country={country}, model_type={model_type}, factor_id={factor_id}, lag={lag}"
        )

    return float(FIXED_LAMBDA2[key])


# ============================================================
# 4. STATE-SPACE MODELS
# ============================================================

class BorioBaselineModel(MLEModel):
    """
    y_t = potential_t + gap_t

    potential_t = 2 potential_{t-1} - potential_{t-2} + eta_t
    gap_t       = beta gap_{t-1} + u_t
    """

    param_names = ["beta"]

    def __init__(self, y, init_state, init_state_cov, sigma2_eta, sigma2_gap):
        self.sigma2_eta = float(sigma2_eta)
        self.sigma2_gap = float(sigma2_gap)

        super().__init__(
            endog=np.asarray(y, dtype=float),
            k_states=3,
            k_posdef=2,
            initialization="known",
            initial_state=init_state,
            initial_state_cov=init_state_cov,
            loglikelihood_burn=2,
        )

        self.ssm["design"] = np.array([[1.0, 0.0, 1.0]])
        self.ssm["obs_cov"] = np.zeros((1, 1))

        self.ssm["selection"] = np.array([
            [1.0, 0.0],
            [0.0, 0.0],
            [0.0, 1.0],
        ])

        self.ssm["state_cov"] = np.diag([
            self.sigma2_eta,
            self.sigma2_gap,
        ])

        self.ssm["transition"] = np.zeros((3, 3))
        self.ssm["state_intercept"] = np.zeros((3, self.nobs))

    def update(self, params, transformed=True, **kwargs):
        params = super().update(params, transformed=transformed, **kwargs)
        beta = params[0]

        dtype = np.result_type(params)

        self.ssm["transition"] = np.array([
            [2.0, -1.0, 0.0],
            [1.0,  0.0, 0.0],
            [0.0,  0.0, beta],
        ], dtype=dtype)

        self.ssm["state_intercept"] = np.zeros((3, self.nobs), dtype=dtype)


class BorioFactorModel(MLEModel):
    """
    y_t = potential_t + gap_t

    potential_t = 2 potential_{t-1} - potential_{t-2} + eta_t
    gap_t       = beta gap_{t-1} + gamma x_{t-lag} + u_t
    """

    param_names = ["beta", "gamma"]

    def __init__(self, y, x, init_state, init_state_cov, sigma2_eta, sigma2_gap):
        self.x = np.asarray(x, dtype=float)
        self.sigma2_eta = float(sigma2_eta)
        self.sigma2_gap = float(sigma2_gap)

        super().__init__(
            endog=np.asarray(y, dtype=float),
            k_states=3,
            k_posdef=2,
            initialization="known",
            initial_state=init_state,
            initial_state_cov=init_state_cov,
            loglikelihood_burn=2,
        )

        self.ssm["design"] = np.array([[1.0, 0.0, 1.0]])
        self.ssm["obs_cov"] = np.zeros((1, 1))

        self.ssm["selection"] = np.array([
            [1.0, 0.0],
            [0.0, 0.0],
            [0.0, 1.0],
        ])

        self.ssm["state_cov"] = np.diag([
            self.sigma2_eta,
            self.sigma2_gap,
        ])

        self.ssm["transition"] = np.zeros((3, 3))
        self.ssm["state_intercept"] = np.zeros((3, self.nobs))

    def update(self, params, transformed=True, **kwargs):
        params = super().update(params, transformed=transformed, **kwargs)
        beta, gamma = params

        dtype = np.result_type(params)

        self.ssm["transition"] = np.array([
            [2.0, -1.0, 0.0],
            [1.0,  0.0, 0.0],
            [0.0,  0.0, beta],
        ], dtype=dtype)

        c = np.zeros((3, self.nobs), dtype=dtype)
        c[2, :] = gamma * self.x

        self.ssm["state_intercept"] = c


# ============================================================
# 5. HELPERS
# ============================================================

def second_diff(series):
    return series.diff().diff()


def gamma_logpdf_from_mean_sd(x, mean, sd):
    if x <= 0:
        return -np.inf

    shape = (mean / sd) ** 2
    scale = (sd ** 2) / mean

    return gamma_dist.logpdf(x, a=shape, scale=scale)


def standardize_series(s):
    s = pd.Series(s).astype(float)
    mu = s.mean()
    sd = s.std()

    if not np.isfinite(sd) or sd <= 0:
        return s - mu

    return (s - mu) / sd


def significance_stars(p):
    if p is None or not np.isfinite(p):
        return ""
    if p < 0.01:
        return "***"
    if p < 0.05:
        return "**"
    if p < 0.10:
        return "*"
    return ""


def safe_z_p(params, se):
    params = np.asarray(params, dtype=float)
    se = np.asarray(se, dtype=float)

    z = np.full_like(params, np.nan, dtype=float)
    p = np.full_like(params, np.nan, dtype=float)

    valid = np.isfinite(se) & (se > 0)

    z[valid] = params[valid] / se[valid]
    p[valid] = 2.0 * (1.0 - norm.cdf(np.abs(z[valid])))

    return z, p


def finite_diff_hessian(f, x, rel_step=1e-5):
    x = np.asarray(x, dtype=float)
    n = len(x)

    h = rel_step * np.maximum(np.abs(x), 1.0)
    H = np.zeros((n, n))
    fx = f(x)

    for i in range(n):
        ei = np.zeros(n)
        ei[i] = h[i]

        H[i, i] = (
            f(x + ei)
            - 2.0 * fx
            + f(x - ei)
        ) / (h[i] ** 2)

        for j in range(i + 1, n):
            ej = np.zeros(n)
            ej[j] = h[j]

            H[i, j] = H[j, i] = (
                f(x + ei + ej)
                - f(x + ei - ej)
                - f(x - ei + ej)
                + f(x - ei - ej)
            ) / (4.0 * h[i] * h[j])

    return H


def safe_standard_errors(neg_obj, params):
    try:
        H = finite_diff_hessian(neg_obj, params)

        if not np.all(np.isfinite(H)):
            return np.full(len(params), np.nan)

        cov = np.linalg.pinv(H)
        diag = np.diag(cov)

        return np.sqrt(np.where(diag > 0, diag, np.nan))

    except Exception:
        return np.full(len(params), np.nan)


# ============================================================
# 6. DATA CONSTRUCTION
# ============================================================

def make_country_factor_data(gdp_df, factors_df, country, factor_col=None, lag=0):
    data = pd.DataFrame(index=gdp_df.index)

    data["real_gdp"] = gdp_df[country]
    data["y"] = 100.0 * np.log(data["real_gdp"])

    if factor_col is not None:
        data["factor_raw"] = factors_df[factor_col].shift(lag)

        if STANDARDIZE_FACTORS:
            data["factor"] = standardize_series(data["factor_raw"])
        else:
            data["factor"] = data["factor_raw"]

    data = data.replace([np.inf, -np.inf], np.nan).dropna()

    return data


# ============================================================
# 7. MODEL CONSTRUCTION
# ============================================================

def make_model_for_lambda(data, lambda2, model_type):
    hp_gap, hp_trend = hpfilter(data["y"], lamb=HP_LAMBDA)

    sigma2_gap = hp_gap.diff().var()
    sigma2_eta = sigma2_gap / lambda2

    if not np.isfinite(sigma2_gap) or sigma2_gap <= 0:
        sigma2_gap = 1.0

    if not np.isfinite(sigma2_eta) or sigma2_eta <= 0:
        sigma2_eta = 1e-4

    init_state = np.array([
        data["y"].iloc[0],
        data["y"].iloc[0],
        0.0,
    ])

    init_state_cov = np.diag([
        sigma2_eta,
        sigma2_eta,
        sigma2_gap,
    ])

    if model_type in ["baseline", "baseline_same_sample"]:
        model = BorioBaselineModel(
            y=data["y"].to_numpy(),
            init_state=init_state,
            init_state_cov=init_state_cov,
            sigma2_eta=sigma2_eta,
            sigma2_gap=sigma2_gap,
        )

    elif model_type == "factor":
        model = BorioFactorModel(
            y=data["y"].to_numpy(),
            x=data["factor"].to_numpy(),
            init_state=init_state,
            init_state_cov=init_state_cov,
            sigma2_eta=sigma2_eta,
            sigma2_gap=sigma2_gap,
        )

    else:
        raise ValueError("model_type must be baseline, baseline_same_sample or factor")

    denom = second_diff(hp_trend).var()

    if np.isfinite(denom) and denom > 0:
        target_ratio = hp_gap.var() / denom
    else:
        target_ratio = np.nan

    hp_info = {
        "hp_gap": hp_gap,
        "hp_trend": hp_trend,
        "sigma2_gap": sigma2_gap,
        "sigma2_eta": sigma2_eta,
        "target_variance_ratio": target_ratio,
    }

    return model, hp_info


# ============================================================
# 8. ESTIMATION GIVEN FIXED LAMBDA2
# ============================================================

def estimate_given_lambda(data, lambda2, model_type):
    model, hp_info = make_model_for_lambda(data, lambda2, model_type)

    def logprior(params):
        params = np.asarray(params, dtype=float)
        beta = params[0]

        if beta <= 0 or beta >= BETA_UPPER:
            return -np.inf

        if not USE_PRIORS:
            return 0.0

        lp = gamma_logpdf_from_mean_sd(
            beta,
            mean=BETA_PRIOR_MEAN,
            sd=BETA_PRIOR_SD,
        )

        return lp

    def negative_log_posterior(params):
        params = np.asarray(params, dtype=float)
        beta = params[0]

        if beta <= 0 or beta >= BETA_UPPER:
            return 1e100

        ll = model.loglike(params, transformed=True)
        lp = logprior(params)

        val = -(ll + lp)

        if not np.isfinite(val):
            return 1e100

        return float(np.real(val))

    beta_starts = [
        0.50,
        0.70,
        0.85,
        min(0.93, BETA_UPPER - 1e-4),
    ]

    if model_type in ["baseline", "baseline_same_sample"]:
        start_grid = [np.array([b]) for b in beta_starts]
        bounds = [(1e-8, BETA_UPPER - 1e-8)]

    else:
        gamma_starts = [-0.5, 0.0, 0.5]
        start_grid = [
            np.array([b, g])
            for b in beta_starts
            for g in gamma_starts
        ]

        bounds = [
            (1e-8, BETA_UPPER - 1e-8),
            (None, None),
        ]

    best_opt = None

    for sp in start_grid:
        opt = minimize(
            negative_log_posterior,
            sp,
            method="L-BFGS-B",
            bounds=bounds,
            options={
                "maxiter": 2000,
                "ftol": 1e-9,
                "gtol": 1e-5,
            },
        )

        if best_opt is None or opt.fun < best_opt.fun:
            best_opt = opt

    params = best_opt.x

    smooth_res = model.smooth(params, transformed=True)

    states = pd.DataFrame(
        smooth_res.smoothed_state.T,
        index=data.index,
        columns=["potential", "potential_lag", "gap_state"],
    )

    output_gap = data["y"] - states["potential"]

    denom = second_diff(states["potential"]).var()

    if np.isfinite(denom) and denom > 0:
        achieved_ratio = output_gap.var() / denom
    else:
        achieved_ratio = np.nan

    loglik = float(model.loglike(params, transformed=True))

    return {
        "model": model,
        "opt": best_opt,
        "params": params,
        "negative_log_posterior": negative_log_posterior,
        "loglik": loglik,
        "hp_info": hp_info,
        "states": states,
        "output_gap": output_gap,
        "achieved_variance_ratio": achieved_ratio,
    }


# ============================================================
# 9. RUN MODEL WITH PREVIOUS LAMBDA2
# ============================================================

def run_model(data, country, model_type, factor_id=None, factor_description=None, lag=None, lambda2=None):
    if len(data) < MIN_OBS:
        raise ValueError(f"Túl kevés megfigyelés: n={len(data)}")

    if lambda2 is None or not np.isfinite(lambda2) or lambda2 <= 0:
        raise ValueError(f"Invalid fixed lambda2: {lambda2}")

    res = estimate_given_lambda(data, lambda2, model_type)

    params = res["params"]
    se = safe_standard_errors(res["negative_log_posterior"], params)
    z, p = safe_z_p(params, se)

    beta = params[0]

    if model_type == "factor":
        gamma = params[1]
        gamma_se = se[1]
        gamma_z = z[1]
        gamma_p = p[1]
        gamma_signif = significance_stars(gamma_p)
    else:
        gamma = np.nan
        gamma_se = np.nan
        gamma_z = np.nan
        gamma_p = np.nan
        gamma_signif = ""

    nobs = len(data)
    k = len(params)
    loglik = res["loglik"]

    aic = -2.0 * loglik + 2.0 * k
    bic = -2.0 * loglik + np.log(nobs) * k

    target = res["hp_info"]["target_variance_ratio"]
    achieved = res["achieved_variance_ratio"]

    if np.isfinite(target) and np.isfinite(achieved) and target > 0 and achieved > 0:
        abs_log_ratio_error = abs(np.log(achieved / target))
    else:
        abs_log_ratio_error = np.nan

    summary = {
        "country": country,
        "model_type": model_type,
        "factor_id": factor_id,
        "factor_description": factor_description,
        "lag": lag,

        "sample_start": str(data.index.min()),
        "sample_end": str(data.index.max()),
        "n_obs": nobs,

        "lambda2_opt": lambda2,
        "lambda2_used": lambda2,
        "lambda_source": "hardcoded_previous_optimization",
        "lambda_error": np.nan,
        "target_variance_ratio": target,
        "achieved_variance_ratio": achieved,
        "abs_log_ratio_error": abs_log_ratio_error,

        "beta": beta,
        "beta_se": se[0],
        "beta_z": z[0],
        "beta_p": p[0],
        "beta_signif": significance_stars(p[0]),
        "beta_boundary_upper": abs(beta - BETA_UPPER) <= 1e-5,

        "gamma": gamma,
        "gamma_se": gamma_se,
        "gamma_z": gamma_z,
        "gamma_p": gamma_p,
        "gamma_signif": gamma_signif,

        "loglik": loglik,
        "aic": aic,
        "bic": bic,
        "n_params": k,
        "converged": res["opt"].success,
        "optimizer_message": str(res["opt"].message),

        "sigma2_gap": res["hp_info"]["sigma2_gap"],
        "sigma2_eta": res["hp_info"]["sigma2_eta"],
    }

    output = data.copy()
    output["potential"] = res["states"]["potential"]
    output["output_gap"] = res["output_gap"]
    output["gap_state"] = res["states"]["gap_state"]
    output["country"] = country
    output["model_type"] = model_type
    output["factor_id"] = factor_id
    output["lag"] = lag
    output["lambda2_opt"] = lambda2
    output["lambda2_used"] = lambda2
    output["beta"] = beta
    output["gamma"] = gamma

    return summary, output


# ============================================================
# 10. BASELINE COMPARISON
# ============================================================

def add_baseline_comparison(summary_df):
    summary_df = summary_df.copy()

    for c in [
        "baseline_loglik_same_sample",
        "baseline_aic_same_sample",
        "baseline_bic_same_sample",
        "delta_loglik_vs_baseline",
        "delta_aic_vs_baseline",
        "delta_bic_vs_baseline",
        "lr_stat_vs_baseline",
        "lr_p_vs_baseline",
    ]:
        summary_df[c] = np.nan

    summary_df["lr_signif_vs_baseline"] = ""

    for idx, row in summary_df.iterrows():
        if row["model_type"] != "factor":
            continue

        mask = (
            (summary_df["country"] == row["country"]) &
            (summary_df["model_type"] == "baseline_same_sample") &
            (summary_df["factor_id"] == row["factor_id"]) &
            (summary_df["lag"] == row["lag"])
        )

        if mask.sum() != 1:
            continue

        base = summary_df.loc[mask].iloc[0]

        d_ll = row["loglik"] - base["loglik"]
        d_aic = row["aic"] - base["aic"]
        d_bic = row["bic"] - base["bic"]

        lr_stat = 2.0 * d_ll
        lr_p = chi2.sf(lr_stat, df=1) if np.isfinite(lr_stat) and lr_stat >= 0 else np.nan

        summary_df.loc[idx, "baseline_loglik_same_sample"] = base["loglik"]
        summary_df.loc[idx, "baseline_aic_same_sample"] = base["aic"]
        summary_df.loc[idx, "baseline_bic_same_sample"] = base["bic"]

        summary_df.loc[idx, "delta_loglik_vs_baseline"] = d_ll
        summary_df.loc[idx, "delta_aic_vs_baseline"] = d_aic
        summary_df.loc[idx, "delta_bic_vs_baseline"] = d_bic
        summary_df.loc[idx, "lr_stat_vs_baseline"] = lr_stat
        summary_df.loc[idx, "lr_p_vs_baseline"] = lr_p
        summary_df.loc[idx, "lr_signif_vs_baseline"] = significance_stars(lr_p)

    return summary_df



# ============================================================
# 11. EUROSTOXX POTENTIAL-OUTPUT OBJECT
# ============================================================

def make_eurostoxx_potential_country_object(
    country,
    factor_col,
    lag,
    base_summary,
    factor_summary,
    base_output,
    factor_output,
):
    """
    Build one country-level comparison table containing:
      - same-sample baseline potential output;
      - Eurostoxx-augmented potential output;
      - the corresponding output gaps and key parameter values.

    The two series are estimated on exactly the same sample.
    """

    out = pd.DataFrame(index=base_output.index.copy())
    out.index.name = "quarter"

    out["country"] = country
    out["factor_id"] = EUROSTOXX_FACTOR_ID
    out["actual_factor_column"] = factor_col
    out["lag"] = lag

    out["real_gdp"] = base_output["real_gdp"]
    out["y"] = base_output["y"]

    if "factor_raw" in factor_output.columns:
        out["eurostoxx_raw"] = factor_output["factor_raw"]

    if "factor" in factor_output.columns:
        out["eurostoxx_factor"] = factor_output["factor"]

    out["potential_same_sample_baseline"] = base_output["potential"]
    out["output_gap_same_sample_baseline"] = base_output["output_gap"]
    out["gap_state_same_sample_baseline"] = base_output["gap_state"]

    out["potential_eurostoxx"] = factor_output["potential"]
    out["output_gap_eurostoxx"] = factor_output["output_gap"]
    out["gap_state_eurostoxx"] = factor_output["gap_state"]

    out["lambda2_same_sample_baseline"] = base_summary["lambda2_used"]
    out["lambda2_eurostoxx"] = factor_summary["lambda2_used"]

    out["beta_same_sample_baseline"] = base_summary["beta"]
    out["beta_eurostoxx"] = factor_summary["beta"]
    out["gamma_eurostoxx"] = factor_summary["gamma"]

    out["sample_start"] = base_summary["sample_start"]
    out["sample_end"] = base_summary["sample_end"]
    out["n_obs"] = base_summary["n_obs"]

    return out


def finalize_eurostoxx_potential_object(eurostoxx_potential_output):
    by_country = eurostoxx_potential_output.get("by_country", {})

    if len(by_country) == 0:
        eurostoxx_potential_output["long"] = pd.DataFrame()
        eurostoxx_potential_output["summary"] = pd.DataFrame()
        return eurostoxx_potential_output

    long_df = pd.concat(
        [df.copy() for df in by_country.values()],
        axis=0,
    ).reset_index()

    long_df["quarter"] = long_df["quarter"].astype(str)

    summary_df_obj = pd.DataFrame(eurostoxx_potential_output.get("summaries", []))

    eurostoxx_potential_output["long"] = long_df
    eurostoxx_potential_output["summary"] = summary_df_obj

    return eurostoxx_potential_output


# ============================================================
# 12. MAIN
# ============================================================

gdp_df = read_quarterly_excel(GDP_EXCEL)

if COUNTRIES is None:
    countries = gdp_df.columns.tolist()
else:
    countries = COUNTRIES

factors_df = get_factors_from_existing_object()

all_summaries = []
all_outputs = []
failed_runs = []

eurostoxx_potential_output = {
    "factor_id": EUROSTOXX_FACTOR_ID,
    "description": "Eurostoxx-augmented and same-sample baseline potential output by country",
    "by_country": {},
    "summaries": [],
}

total_runs = len(countries) * len(FACTOR_SPECS)
progress_bar = tqdm(total=total_runs, desc="Estimating models", unit="spec") if tqdm is not None else None

for country in countries:

    if country not in gdp_df.columns:
        failed_runs.append({
            "country": country,
            "factor_id": None,
            "error": "Country column missing from GDP file",
        })
        if progress_bar is not None:
            progress_bar.update(len(FACTOR_SPECS))
        continue

    for fs in FACTOR_SPECS:

        factor_id = fs["factor_id"]
        lag = fs["lag"]
        factor_description = fs["description"]

        try:
            factor_col = find_column(factors_df, fs["aliases"])

            data_factor = make_country_factor_data(
                gdp_df=gdp_df,
                factors_df=factors_df,
                country=country,
                factor_col=factor_col,
                lag=lag,
            )

            data_baseline_same = data_factor.drop(
                columns=[c for c in ["factor_raw", "factor"] if c in data_factor.columns]
            ).copy()

            baseline_lambda2 = get_fixed_lambda(
                country=country,
                model_type="baseline_same_sample",
                factor_id=factor_id,
                lag=lag,
            )

            factor_lambda2 = get_fixed_lambda(
                country=country,
                model_type="factor",
                factor_id=factor_id,
                lag=lag,
            )

            base_summary, base_output = run_model(
                data=data_baseline_same,
                country=country,
                model_type="baseline_same_sample",
                factor_id=factor_id,
                factor_description=f"Same-sample baseline for {factor_id}, lag {lag}",
                lag=lag,
                lambda2=baseline_lambda2,
            )

            factor_summary, factor_output = run_model(
                data=data_factor,
                country=country,
                model_type="factor",
                factor_id=factor_id,
                factor_description=factor_description,
                lag=lag,
                lambda2=factor_lambda2,
            )

            base_summary["actual_factor_column"] = factor_col
            factor_summary["actual_factor_column"] = factor_col

            base_output["actual_factor_column"] = factor_col
            factor_output["actual_factor_column"] = factor_col

            all_summaries.append(base_summary)
            all_summaries.append(factor_summary)

            all_outputs.append(base_output)
            all_outputs.append(factor_output)

            if factor_id == EUROSTOXX_FACTOR_ID:
                eurostoxx_country_df = make_eurostoxx_potential_country_object(
                    country=country,
                    factor_col=factor_col,
                    lag=lag,
                    base_summary=base_summary,
                    factor_summary=factor_summary,
                    base_output=base_output,
                    factor_output=factor_output,
                )

                eurostoxx_potential_output["by_country"][country] = eurostoxx_country_df
                eurostoxx_potential_output["summaries"].append({
                    "country": country,
                    "factor_id": factor_id,
                    "actual_factor_column": factor_col,
                    "lag": lag,
                    "sample_start": base_summary["sample_start"],
                    "sample_end": base_summary["sample_end"],
                    "n_obs": base_summary["n_obs"],
                    "lambda2_same_sample_baseline": base_summary["lambda2_used"],
                    "lambda2_eurostoxx": factor_summary["lambda2_used"],
                    "beta_same_sample_baseline": base_summary["beta"],
                    "beta_eurostoxx": factor_summary["beta"],
                    "gamma_eurostoxx": factor_summary["gamma"],
                    "aic_same_sample_baseline": base_summary["aic"],
                    "aic_eurostoxx": factor_summary["aic"],
                    "bic_same_sample_baseline": base_summary["bic"],
                    "bic_eurostoxx": factor_summary["bic"],
                })

            if progress_bar is not None:
                progress_bar.update(1)

        except Exception as e:
            failed_runs.append({
                "country": country,
                "factor_id": factor_id,
                "lag": lag,
                "error": str(e),
            })

            if progress_bar is not None:
                progress_bar.update(1)

if progress_bar is not None:
    progress_bar.close()

summary_df = pd.DataFrame(all_summaries)

if not summary_df.empty:
    summary_df = add_baseline_comparison(summary_df)

factor_results = (
    summary_df[summary_df["model_type"] == "factor"].copy()
    if not summary_df.empty else pd.DataFrame()
)

baseline_results = (
    summary_df[summary_df["model_type"] == "baseline_same_sample"].copy()
    if not summary_df.empty else pd.DataFrame()
)

failed_df = pd.DataFrame(failed_runs)

if not factor_results.empty:
    factor_results_sorted = factor_results.sort_values(
        ["country", "delta_aic_vs_baseline", "gamma_p"],
        ascending=[True, True, True],
    )
else:
    factor_results_sorted = pd.DataFrame()

if len(all_outputs) > 0:
    outputs_long = pd.concat(all_outputs, axis=0).reset_index()
    outputs_long = outputs_long.rename(columns={"index": "quarter"})
    outputs_long["quarter"] = outputs_long["quarter"].astype(str)
else:
    outputs_long = pd.DataFrame()


eurostoxx_potential_output = finalize_eurostoxx_potential_object(eurostoxx_potential_output)
eurostoxx_potential_output_long = eurostoxx_potential_output["long"]


print("\n" + "#" * 100)
print("FINAL FACTOR RESULTS")
print("#" * 100)

display_cols = [
    "country",
    "factor_id",
    "actual_factor_column",
    "lag",
    "sample_start",
    "sample_end",
    "n_obs",
    "lambda2_opt",
    "lambda2_used",
    "target_variance_ratio",
    "achieved_variance_ratio",
    "abs_log_ratio_error",
    "beta",
    "beta_se",
    "beta_p",
    "beta_signif",
    "gamma",
    "gamma_se",
    "gamma_p",
    "gamma_signif",
    "loglik",
    "aic",
    "bic",
    "delta_aic_vs_baseline",
    "delta_bic_vs_baseline",
    "lr_p_vs_baseline",
    "lr_signif_vs_baseline",
    "converged",
]

if not factor_results.empty:
    cols = [c for c in display_cols if c in factor_results.columns]
    print(factor_results[cols].round(6).to_string(index=False))
else:
    print("No successful factor results.")