msd-backtest 0.1.0__py3-none-any.whl

mbt/run/cli.py

@@ -0,0 +1,192 @@
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+import datetime
+from mbt import Runner, Account, Fee
+from mbt.run import Report, build_report, build_json_report, RunRequest
+from mbt.run.msd import load_data
+import logging
+from typing import Tuple
+import argparse
+import pandas as pd
+import orjson
+import os
+import numpy as np
+
+logging.basicConfig(
+  format="%(asctime)s %(name)s %(levelname)s %(message)s", level=logging.INFO
+)
+
+logger = logging.getLogger("backtest")
+
+
+def expand_symbols(symbols: list[str]) -> list[str]:
+  """read as file when input is a file path, and expand it. otherwise, return the input as a list of symbols"""
+  expanded = []
+  for s in symbols:
+    if os.path.isfile(s):
+      with open(s, "r") as f:
+        lines = filter(
+          lambda x: len(x) > 0 and not x.startswith("#"),
+          map(lambda x: x.strip(), f.readlines()),
+        )
+        expanded.extend(lines)
+    else:
+      expanded.append(s)
+
+  return expanded
+
+
+def parse_args() -> Tuple[RunRequest, str, str, Fee]:
+  parser = argparse.ArgumentParser(description="Run a strategy")
+  parser.add_argument(
+    "strategy",
+    help="Strategy to run, can be a JSON file or a Python file",
+  )
+  parser.add_argument("-s", "--symbols", nargs="+", default=[], help="Symbols to run")
+  parser.add_argument("-B", "--benchmark", type=str, default=os.environ.get("MSD_BT_BENCHMARK", "SH000300"), help="Benchmark symbol, env $MSD_BT_BENCHMARK")
+  parser.add_argument(
+    "-b", "--begin", type=str, default=os.environ.get("MSD_BT_BEGIN", "2020-01-01"), help="Start date, env $MSD_BT_BEGIN"
+  )
+  parser.add_argument("-e", "--end", type=str, default=os.environ.get("MSD_BT_END", "2020-12-31"), help="End date, env $MSD_BT_END")
+  parser.add_argument("-a", "--args", nargs="*", help="Strategy arguments")
+  parser.add_argument(
+    "-m", "--msd", type=str, default=os.environ.get("MSD_HOST", "http://localhost:50510"), help="MSD host, env $MSD_HOST"
+  )
+  parser.add_argument(
+    "-o",
+    "--output",
+    default="",
+    help="output to, empty to stdout, or any supported file path, csv, json, excel",
+  )
+  parser.add_argument(
+    "-f",
+    "--fee",
+    default=os.environ.get("MSD_BT_FEE", ""),
+    help="fee config path, env $MSD_BT_FEE",
+  )
+  parser.add_argument("-V", "--verbose", action="store_true", help="verbose output")
+  args = parser.parse_args()
+
+  if args.verbose:
+    logging.getLogger().setLevel(logging.DEBUG)
+
+
+  args.symbols = expand_symbols(args.symbols)
+
+  if args.strategy.endswith(".json"):
+    with open(args.strategy, "r") as f:
+      req = RunRequest.from_json(
+        f,
+        symbols=args.symbols,
+        start=args.begin,
+        end=args.end,
+        args=args.args,
+      )
+  elif args.strategy.endswith(".py"):
+    with open(args.strategy, "r") as f:
+      req = RunRequest(
+        f,
+        args.symbols,
+        start=args.begin,
+        end=args.end,
+        args=args.args,
+      )
+  else:
+    raise ValueError("Invalid strategy type")
+
+  if len(args.symbols) == 0:
+    raise ValueError("No symbols provided")
+
+  try:
+    args.symbols.remove(args.benchmark)
+  except ValueError:
+    pass
+
+  args.symbols.insert(0, args.benchmark)
+
+  fee = Fee(args.fee_json) if len(args.fee_json) > 0 else Fee()
+
+  return req, args.msd, args.output, fee
+
+
+def float_format(f: float) -> str:
+  s = f"{f:.6f}"
+  if "." in s:
+    s = s.rstrip("0").rstrip(".")
+  return s
+
+def json_default(self, o):
+  if isinstance(o, (np.ndarray, np.generic)):
+    return o.tolist()
+  elif isinstance(o, np.datetime64):
+    return np.datetime_as_string(o, 's').rstrip("T00:00:00")
+  elif isinstance(o, datetime.datetime):
+    return o.strftime("%Y-%m-%dT%X").rstrip("T00:00:00")
+  elif isinstance(o, float):
+    return round(o, 6)
+  return o
+
+
+def build_output(reports: list[Report], output: str):
+  ext = output.split(".")[-1].lower()
+  logger.info(f"output kind: {ext}")
+  if ext == "csv":
+    for report in reports:
+      df = pd.DataFrame(report.detailed(with_symbol=True))
+      df.to_csv(output, index=False, float_format=float_format)  # type: ignore
+  elif ext == "xlsx":
+    with pd.ExcelWriter(output) as writer:
+      df_metrics = pd.DataFrame([r.metrics(True) for r in reports])
+      df_metrics.to_excel(writer, sheet_name="metrics", index=False)
+      for report in reports:
+        data = report.detailed()
+        data['price'] = report.price
+        data['fw_price'] = report.fw_price
+        data['bw_price'] = report.bw_price
+        df = pd.DataFrame(data)
+        df.to_excel(
+          writer,
+          sheet_name=report.symbol,
+          index=False,
+          float_format="%.6f",
+        )
+  elif ext == "json":
+    data = build_json_report(reports)
+    logger.info("build json")
+    with open(output, "wb") as f:
+      f.write(orjson.dumps(data, option=orjson.OPT_INDENT_2 | orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_OMIT_MICROSECONDS))
+  else:
+    raise ValueError(f"unsupported output format: {ext}")
+  logger.info(f"output saved to: {output}")
+
+
+def echo_reports(reports: list[Report]):
+  df_metrics = pd.DataFrame([r.metrics(True) for r in reports])
+  print(df_metrics.to_json(orient='records', indent=2))
+
+
+def main():
+  req, msd_host, output, fee = parse_args()
+  logger.info(f"load data from {msd_host}")
+  dp, symbols = load_data(msd_host, req.symbols, req.start, req.end)
+  logger.info(
+    f"data loaded, symbols: {len(symbols)}, bars per symbol: {dp.bars}, total_bars: {dp.groups * dp.bars}"
+  )
+  account = Account(10000.0, dp, fee=fee)
+  logger.info("account created")
+  runner = Runner(account)
+  logger.info("runner created")
+  runner.run(req.strategy)
+  logger.info("strategy finished")
+  reports = build_report(dp, runner.ctx.accounts)[1:]
+  logger.info("report built")
+  if len(output) > 0:
+    build_output(reports, output)
+  else:
+    echo_reports(reports)
+
+
+if __name__ == "__main__":
+  main()

mbt/run/msd.py

@@ -0,0 +1,76 @@
+import pymsd
+from mbt import DataProvider
+import alpha as al
+import numpy as np
+import logging
+
+logger = logging.getLogger("msd_loader")
+
+
+
+def next_hook_al(i: int, groups: int, bars: int):
+  al.set_ctx(end=i + 1)
+
+
+def load_data(
+  msd_host: str, symbols: list[str], start: str, end: str
+) -> tuple[DataProvider, list[str]]:
+  """
+  create a DataProvider for backtesting from msd database.
+
+  Args:
+    msd_host: msd server host
+    symbols: symbols to backtest
+    start: start date
+    end: end date
+
+  Returns:
+    DataProvider and symbols
+  """
+
+  client = pymsd.create_msd_pandas(msd_host)
+
+  dfs = client.load(
+    objs=symbols,
+    tables=["stock_kline_1d", "stock_dividend", "stock_financial"],
+    join={"stock_dividend": "zero", "*": "backward"},
+    start=start,
+    end=end,
+  )
+  logger.info(f"data loaded from msd, {len(dfs)} symbols")
+
+  data, symbols = client.adaptor.concat(dfs, base=symbols[0], join="nan")
+  logger.info("data concatenated")
+  if data is None or "ts" not in data:
+    return DataProvider({"ts": np.array([])}, symbols=[]), []
+
+  data = client.adaptor.to_numpy(data)
+
+  dp = DataProvider(data, symbols=symbols, next_hook=next_hook_al)
+
+  # keep original as price
+  data["price"] = data["close"].copy()
+
+  al.set_ctx(groups=dp.groups, flags=al.FLAG_SKIP_NAN)
+  data["bw_price"] = al.BW_SPLIT(data["close"], data["dividend"], data["transfer_shares"], data["right_shares"], data["right_price"])
+  data["fw_price"] = al.FW_SPLIT(data["close"], data["dividend"], data["transfer_shares"], data["right_shares"], data["right_price"])
+
+  logger.info("adjustment factors generated")
+  # apply forward factor to all price related columns used to do technical analysis
+  data["open"] = al.FW_SPLIT(data["open"], data["dividend"], data["transfer_shares"], data["right_shares"], data["right_price"])
+  data["high"] = al.FW_SPLIT(data["high"], data["dividend"], data["transfer_shares"], data["right_shares"], data["right_price"])
+  data["low"] = al.FW_SPLIT(data["low"], data["dividend"], data["transfer_shares"], data["right_shares"], data["right_price"])
+  data["close"] = data["fw_price"]
+  data["vwap"] = data["amount"] / data["volume"]
+  # check if it is limited: 
+  is_limit_up = (data["close"] == data["high"]) & (data["open"] == data["high"]) & (data["close"] > al.REF(data["close"], 1)) 
+  is_limit_down = (data["close"] == data["low"]) & (data["open"] == data["low"]) & (data["close"] < al.REF(data["close"], 1))
+  data["limited"] = np.where(is_limit_up, 1, np.where(is_limit_down, -1, 0))
+  logger.info("adjustment factors applied")
+
+  if dp.bars == 0:
+    raise ValueError("No data found for the given symbols and date range.")
+
+  # reset al context
+  al.set_ctx(groups=dp.groups, flags=al.FLAG_SKIP_NAN, start=0, end=1)
+  return dp, symbols

mbt/run/report.py

@@ -0,0 +1,313 @@
+from mbt import Account
+from mbt import DataProvider
+import pandas as pd
+import numpy as np
+import dataclasses
+
+
+@dataclasses.dataclass
+class Report:
+  symbol: str
+  date: np.ndarray 
+  ror: np.ndarray
+  ror_hold: np.ndarray
+  ror_original: np.ndarray
+  actions: np.ndarray
+  price: np.ndarray
+  close: np.ndarray
+  fw_price: np.ndarray
+  bw_price: np.ndarray
+  alpha: float
+  beta: float
+  sharpe: float
+  information_ratio: float
+  ir: float
+  sortino: float
+  treynor: float
+  max_drawdown: float
+  calmar: float
+  win_rate: float
+  avg_win: float
+  avg_loss: float
+  profit_factor: float
+  profit: float
+  profit_original: float
+  fee_rate: float
+  trade_count: int
+  
+
+  def __init__(self, symbol: str, dp: DataProvider , account: Account ):
+    if len(symbol) == 0:
+      return
+    self.symbol = symbol
+    s, e = dp.symbol_indices(symbol)
+    self.date = dp.dates[s:e]
+    
+
+    self.ror = np.round(dp.slice("ror", s), 4)
+    self.ror_hold = np.round(dp.slice("ror_hold", s), 4)
+    self.ror_original = np.round(uniform_ror(dp.slice("bw_price", s)), 4)
+    
+    # Clean NaNs by forward filling and filling leading NaNs with 0
+    self.ror = pd.Series(self.ror).ffill().fillna(0.0).values
+    self.ror_hold = pd.Series(self.ror_hold).ffill().fillna(0.0).values
+    self.ror_original = pd.Series(self.ror_original).ffill().fillna(0.0).values
+
+    self.actions = dp.slice("actions", s)
+    self.price = dp.slice("price", s)
+    self.close = self.price # For compatibility with tests
+    self.fw_price = np.round(dp.slice("fw_price", s), 3)
+    self.bw_price = np.round(dp.slice("bw_price", s), 3)
+    
+    self.calculate_metrics(dp, account)
+    
+
+  @staticmethod
+  def from_dict(symbol: str, d: dict) -> Report:
+    r = Report('', None, None) # type: ignore
+    r.symbol = symbol
+    r.date = d.get('date', np.array([], dtype='int64'))
+    r.ror = np.array(d.get('ror', []), dtype='float64')
+    r.ror_hold = np.array(d.get('ror_hold', []), dtype='float64')
+    r.ror_original = np.array(d.get('ror_original', []), dtype='float64')
+    r.actions = np.array(d.get('actions', []), dtype='int8')
+    r.price = np.array(d.get('price', []), dtype='float64')
+    r.close = r.price
+    r.fw_price = np.array(d.get('fw_price', []), dtype='float64')
+    r.bw_price = np.array(d.get('bw_price', []), dtype='float64')
+    
+    r.alpha = d.get('alpha', 0.0)
+    r.beta = d.get('beta', 0.0)
+    r.sharpe = d.get('sharpe', 0.0)
+    r.information_ratio = d.get('information_ratio', 0.0)
+    r.ir = d.get('ir', 0.0)
+    r.sortino = d.get('sortino', 0.0)
+    r.treynor = d.get('treynor', 0.0)
+    r.max_drawdown = d.get('max_drawdown', 0.0)
+    r.calmar = d.get('calmar', 0.0)
+    r.win_rate = d.get('win_rate', 0.0)
+    r.avg_win = d.get('avg_win', 0.0)
+    r.avg_loss = d.get('avg_loss', 0.0)
+    r.profit_factor = d.get('profit_factor', 0.0)
+    r.profit = d.get('profit', 0.0)
+    r.profit_original = d.get('profit_original', 0.0)
+    r.fee_rate = d.get('fee_rate', 0.0)
+    r.trade_count = d.get('trade_count', 0)
+
+    return r    
+    
+
+
+  def calculate_metrics(self, dp: DataProvider, account: Account):
+    benchmark = uniform_ror(dp.slice("bw_price", 0))
+
+    # 1. Convert cumulative returns to daily returns
+    strategy_ratio = 1.0 + self.ror
+    benchmark_ratio = 1.0 + benchmark
+
+    if len(strategy_ratio) > 1:
+      strategy_daily = np.diff(strategy_ratio) / strategy_ratio[:-1]
+      benchmark_daily = np.diff(benchmark_ratio) / benchmark_ratio[:-1]
+    else:
+      strategy_daily = np.array([], dtype=np.float64)
+      benchmark_daily = np.array([], dtype=np.float64)
+
+    # 2. Portfolio/Strategy metrics calculations
+    if len(strategy_daily) >= 2:
+      # Sharpe
+      mean_strat = np.mean(strategy_daily)
+      std_strat = np.std(strategy_daily, ddof=1)
+      sharpe = (mean_strat / std_strat * np.sqrt(252)) if std_strat != 0.0 else 0.0
+
+      # Beta
+      cov = np.cov(strategy_daily, benchmark_daily)
+      var_bench = cov[1, 1]
+      beta = (cov[0, 1] / var_bench) if var_bench != 0.0 else 0.0
+
+      # Alpha
+      mean_bench = np.mean(benchmark_daily)
+      alpha = (mean_strat - beta * mean_bench) * 252
+
+      # Information Ratio (IR)
+      active_daily = strategy_daily - benchmark_daily
+      mean_active = np.mean(active_daily)
+      std_active = np.std(active_daily, ddof=1)
+      ir = (mean_active / std_active * np.sqrt(252)) if std_active != 0.0 else 0.0
+
+      # Sortino
+      downside_daily = np.minimum(strategy_daily, 0.0)
+      std_downside = np.std(downside_daily, ddof=1)
+      sortino = (mean_strat / std_downside * np.sqrt(252)) if std_downside != 0.0 else 0.0
+
+      # Treynor
+      treynor = (mean_strat * 252 / beta) if beta != 0.0 else 0.0
+    else:
+      sharpe = 0.0
+      beta = 0.0
+      alpha = 0.0
+      ir = 0.0
+      sortino = 0.0
+      treynor = 0.0
+
+    # Max Drawdown
+    if len(self.ror) > 0:
+      equity = 1.0 + self.ror
+      peaks = np.maximum.accumulate(equity)
+      drawdowns = (equity - peaks) / peaks
+      max_drawdown = np.min(drawdowns)
+    else:
+      max_drawdown = 0.0
+
+    # Calmar
+    if max_drawdown != 0.0 and len(strategy_daily) >= 2:
+      calmar = (np.mean(strategy_daily) * 252) / abs(max_drawdown)
+    else:
+      calmar = 0.0
+
+    # 3. Trade-level metrics
+    action_shares = dp.slice("action_shares", self.symbol) if "action_shares" in dp.data else np.zeros_like(self.price)
+
+    # Track shares held at each bar
+    shares = np.zeros(len(self.actions))
+    curr_shares = 0.0
+    for t in range(len(self.actions)):
+      act = self.actions[t]
+      sh = action_shares[t]
+      if act == 1:    # ACTION_BUY
+        curr_shares += sh
+      elif act == 2:  # ACTION_SELL
+        curr_shares -= sh
+      shares[t] = max(curr_shares, 0.0)
+
+    # Identify holding periods where shares > 0
+    holding = shares > 0
+    padded = np.concatenate(([False], holding, [False]))
+    diff = np.diff(padded.astype(int))
+    starts = np.where(diff == 1)[0]
+    ends = np.where(diff == -1)[0] - 1
+
+    trade_profits = []
+    trade_returns = []
+
+    s = dp.symbols.index(self.symbol) * dp.bars
+    e = s + dp.bars
+    assets = dp.all("assets")[s:e]
+
+    for s_idx, e_idx in zip(starts, ends):
+      base_idx = s_idx - 1 if s_idx > 0 else 0
+      base_asset = assets[base_idx]
+
+      final_idx = min(e_idx + 1, len(assets) - 1)
+      final_asset = assets[final_idx]
+
+      profit = final_asset - base_asset
+      trade_profits.append(profit)
+
+      ret = (profit / base_asset) if base_asset != 0.0 else 0.0
+      trade_returns.append(ret)
+
+    if trade_profits:
+      wins = [p for p in trade_profits if p > 0]
+      losses = [p for p in trade_profits if p < 0]
+
+      wins_ret = [r for r in trade_returns if r > 0]
+      losses_ret = [r for r in trade_returns if r < 0]
+
+      win_rate = len(wins) / len(trade_profits)
+      avg_win = np.mean(wins_ret) if wins_ret else 0.0
+      avg_loss = np.mean(losses_ret) if losses_ret else 0.0
+
+      sum_loss = abs(sum(losses))
+      profit_factor = sum(wins) / sum_loss if sum_loss != 0.0 else 0.0
+    else:
+      win_rate = 0.0
+      avg_win = 0.0
+      avg_loss = 0.0
+      profit_factor = 0.0
+
+    # 4. Store all metrics as attributes
+    self.alpha = 0.0 if np.isnan(alpha) else np.round(alpha, 4)
+    self.beta = 0.0 if np.isnan(beta) else np.round(beta, 4)
+    self.sharpe = 0.0 if np.isnan(sharpe) else np.round(sharpe, 4)
+    self.information_ratio = 0.0 if np.isnan(ir) else np.round(ir, 4)
+    self.ir = self.information_ratio # For compatibility with tests
+    self.sortino = 0.0 if np.isnan(sortino) else np.round(sortino, 4)
+    self.treynor = 0.0 if np.isnan(treynor) else np.round(treynor, 4)
+    self.max_drawdown = 0.0 if np.isnan(max_drawdown) else np.round(max_drawdown, 4)
+    self.calmar = 0.0 if np.isnan(calmar) else np.round(calmar, 4)
+
+    self.win_rate = 0.0 if np.isnan(win_rate) else np.round(win_rate, 4)
+    self.avg_win = 0.0 if np.isnan(avg_win) else np.round(avg_win, 4)
+    self.avg_loss = 0.0 if np.isnan(avg_loss) else np.round(avg_loss, 4)
+    self.profit_factor = 0.0 if np.isnan(profit_factor) else np.round(profit_factor, 4)
+    self.profit = self.ror[-1] if self.ror.size > 0 else 0.0
+    self.profit_original = self.ror_original[-1] if self.ror_original.size > 0 else 0.0
+    self.fee_rate = np.round(account.deducted / account.initial_cash, 4)
+    self.trade_count = len(trade_profits)
+    
+
+  def metrics(self, with_symbol: bool = False) -> dict:
+    d = {
+      "symbol": self.symbol,
+      "profit": self.profit,
+      "profit_original": self.profit_original,
+      "alpha": self.alpha,
+      "beta": self.beta,
+      "sharpe": self.sharpe,
+      "information_ratio": self.information_ratio,
+      "sortino": self.sortino,
+      "treynor": self.treynor,
+      "max_drawdown": self.max_drawdown,
+      "calmar": self.calmar,
+      "win_rate": self.win_rate,
+      "avg_win": self.avg_win,
+      "avg_loss": self.avg_loss,
+      "profit_factor": self.profit_factor,
+      "fee_rate": self.fee_rate,
+      "trade_count": self.trade_count,
+    }
+    if not with_symbol:
+      del d["symbol"]
+    return d
+
+  def detailed(self, with_symbol: bool = False) -> dict:
+    d = {
+      "symbol": [self.symbol] * len(self.date),
+      "date": self.date,
+      "ror": self.ror,
+      "ror_hold": self.ror_hold,
+      "ror_original": self.ror_original,
+      "actions": self.actions,
+    }
+    if not with_symbol:
+      del d["symbol"]
+    return d
+
+def uniform_ror(a: np.ndarray) -> np.ndarray:
+  base = a[0]
+  if base == 0:
+    return a
+  return ((a - base) / base)
+
+
+def build_report(dp: DataProvider, accounts: list[Account]) -> list[Report]:
+  reports = [Report(symbol, dp, accounts[i]) for i, symbol in enumerate(dp.symbols)]
+
+  return reports
+
+
+def build_json_report(reports: list[Report]) -> dict:
+  """Helper to build a JSON report from DataProvider"""
+
+  data = {}
+  for report in reports:
+    d = {}
+    d.update(report.metrics())
+    d.update(report.detailed())
+    data[report.symbol] = d
+  return data
+
+
+
+
+  

mbt/run/review.py

@@ -0,0 +1,67 @@
+from mbt.run.report import Report
+import orjson
+import sys
+import argparse
+import pandas as pd
+
+
+
+def parse_args():
+  parser = argparse.ArgumentParser(description="Review a backtest report")
+  parser.add_argument("report", type=str, help="Path to the report file")
+
+  sub_commands = parser.add_subparsers(dest="command", required=True)
+
+  stat_parser = sub_commands.add_parser("stat", help="Show statistics")
+  stat_parser.set_defaults(func=do_stat)
+
+  sort_parser = sub_commands.add_parser("sort", help="Sort by a metric")
+  sort_parser.add_argument("-m", "--metric", type=str, help="Metric to sort by")
+  sort_parser.add_argument("-o", "--order", type=str, help="Order, desc or asc", default="desc")
+  sort_parser.add_argument("-l", "--limit", type=int, help="Limit number of symbols")
+  sort_parser.set_defaults(func=do_sort)
+
+  detail_parser = sub_commands.add_parser("detail", help="Show detail for a symbol")
+  detail_parser.add_argument("-s", "--symbol", type=str, help="Symbol to show")
+  detail_parser.set_defaults(func=do_detail)
+  
+  return parser.parse_args()
+
+def do_stat(args):
+  reports = load_reports(args.report)
+  df = pd.DataFrame([r.metrics(True) for r in reports.values()])
+  df.set_index("symbol", inplace=True)
+  stat = df.describe()
+  print(stat.to_json())
+
+def do_detail(args):
+  reports = load_reports(args.report)
+  symbol_report = reports[args.symbol]
+  d = {}
+  d.update(symbol_report.detailed(False))
+  d.update(symbol_report.metrics(True))
+  print(orjson.dumps(d, option=orjson.OPT_SERIALIZE_NUMPY))
+
+def do_sort(args):
+  reports = load_reports(args.report)
+  df = pd.DataFrame([{"symbol":r.symbol, args.metric: getattr(r, args.metric, 0)} for r in reports.values()])
+  df.set_index("symbol", inplace=True)
+  df = df.sort_values(by=args.metric, ascending=args.order == "asc")
+  if args.limit:
+    df = df.head(args.limit)
+  print(df.to_json(orient="columns"))
+  
+def load_reports(report_path: str) -> dict[str, Report]:
+  with open(report_path, "r") as f:
+    data = orjson.loads(f.read())
+  return {symbol: Report.from_dict(symbol, data[symbol]) for symbol in data}
+
+
+def main():
+  args = parse_args()
+  args.func(args)
+
+
+if __name__ == "__main__":
+  main()
+