# region imports
from AlgorithmImports import *
# endregion

from run_strategy import run_strategy

# Every ticker weathervane_logic.py's generated run_strategy() references (kept as an
# explicit list here rather than parsed at runtime, so a missing/renamed ticker fails
# fast at initialize() instead of mid-backtest). The strategy's own rebalance cadence is
# "daily" (see the score JSON's top-level "rebalance" field).
WEATHERVANE_TICKERS = [
    "AAPX", "AGG", "AGQ", "AMZN", "AMZU", "AMZZ", "BABA", "BAM", "BIL", "BITX", "BN",
    "BND", "BTAL", "BX", "COIN", "CONL", "EDC", "EDZ", "EEM", "FAS", "FAZ", "FBL",
    "GDXD", "GDXU", "GGLL", "GLD", "HOOD", "IBKR", "IEF", "IEI", "IGIB", "IOO", "IUSV",
    "IVW", "IWM", "KKR", "KMLM", "MA", "META", "NVDL", "PLTR", "PSQ", "QLD", "QQQ",
    "QQQE", "RGTI", "SCHW", "SH", "SHV", "SOFI", "SOXL", "SOXS", "SPXL", "SPY", "SQQQ",
    "SVIX", "TECL", "TECS", "TLT", "TMF", "TQQQ", "TSLA", "TSLR", "UGL", "UPRO", "UVXY",
    "V", "VIXM", "VIXY", "VOOG", "VOOV", "VOX", "VTR", "VTV", "WELL", "XLF", "XLK",
    "XLP", "XLY",
]

# Largest lhs-/rhs-/sort-by- window the symphony actually uses (200 trading days),
# with margin. See symphony_codegen.py's module docstring for the schema this was
# built against, and its caveats -- generated logic is a best-effort translation of
# Composer's JSON, not a confirmed bit-for-bit reproduction of Composer's own engine.
HISTORY_WINDOW_DAYS = 220


class Weathervane(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2021, 7, 1)
        # self.set_end_date(2026, 8, 9)
        self.set_cash(10000)
        self.set_warm_up(HISTORY_WINDOW_DAYS, Resolution.DAILY)

        self._symbols = {}
        for ticker in WEATHERVANE_TICKERS:
            try:
                security = self.add_equity(ticker, Resolution.DAILY)
                self._symbols[ticker] = security.symbol
            except Exception as e:
                # Some of these are newer leveraged/thematic products that may not have
                # data over the full backtest window, or may not resolve on this data
                # feed at all -- log and continue rather than aborting the whole
                # backtest over one bad ticker.
                self.debug(f"Could not add equity {ticker}: {e}")

        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.after_market_open("SPY", 10),
            self.rebalance,
        )

    def rebalance(self):
        if self.is_warming_up:
            return

        # Every ticker gets an entry, always exactly HISTORY_WINDOW_DAYS long: a ticker
        # not yet listed / with thin history is front-padded with its own earliest known
        # price (or 1.0 if it has no data at all yet) rather than omitted. Omitting it
        # instead causes a bare KeyError deep inside run_symphony() the moment any branch
        # of the symphony logic references that ticker -- a try/except around
        # run_symphony() here did not reliably prevent that from aborting the whole
        # backtest in testing, so this avoids relying on catching it at all. The
        # trade-off: a not-yet-listed ticker looks "flat" (0% return, neutral RSI) for
        # the padded portion -- a deliberate simplification, not real history.
        prices = {}
        for ticker, symbol in self._symbols.items():
            hist = self.history(symbol, HISTORY_WINDOW_DAYS, Resolution.DAILY)
            closes = hist["close"].tolist() if (not hist.empty and "close" in hist.columns) else []
            if len(closes) < HISTORY_WINDOW_DAYS:
                pad_value = closes[0] if closes else 1.0
                closes = [pad_value] * (HISTORY_WINDOW_DAYS - len(closes)) + closes
            prices[ticker] = closes

        try:
            weights = run_strategy(prices)
        except Exception as e:
            # Last-resort safety net for anything unanticipated -- not relied on for the
            # routine missing-data case anymore (see above).
            self.debug(f"run_strategy failed on {self.time}: {e}")
            return

        targets = [
            PortfolioTarget(self._symbols[ticker], weight)
            for ticker, weight in weights.items()
            if ticker in self._symbols
        ]
        self.set_holdings(targets, liquidate_existing_holdings=True)

# region imports
from AlgorithmImports import *
# endregion
"""
Auto-generated from a strategy's JSON score by the code generator module.
Do not hand-edit -- regenerate instead. See the code generator's module
docstring for the schema-confidence caveats before trusting this.
"""
from typing import Dict, Sequence

import strategy_runtime as rt
import weathervane_part_0  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_1  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_2  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_3  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_4  # noqa: F401 -- registers this chunk's node functions


def run_strategy(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    """Returns {ticker: target weight}. `prices` needs a chronological (oldest
    first) daily-close series for every ticker referenced below:
    'AAPX', 'AGG', 'AGQ', 'AMZN', 'AMZU', 'AMZZ', 'BABA', 'BAM', 'BIL', 'BITX', 'BN', 'BND', 'BTAL', 'BX', 'COIN', 'CONL', 'EDC', 'EDZ', 'EEM', 'FAS', 'FAZ', 'FBL', 'GDXD', 'GDXU', 'GGLL', 'GLD', 'HOOD', 'IBKR', 'IEF', 'IEI', 'IGIB', 'IOO', 'IUSV', 'IVW', 'IWM', 'KKR', 'KMLM', 'MA', 'META', 'NVDL', 'PLTR', 'PSQ', 'QLD', 'QQQ', 'QQQE', 'RGTI', 'SCHW', 'SH', 'SHV', 'SOFI', 'SOXL', 'SOXS', 'SPXL', 'SPY', 'SQQQ', 'SVIX', 'TECL', 'TECS', 'TLT', 'TMF', 'TQQQ', 'TSLA', 'TSLR', 'UGL', 'UPRO', 'UVXY', 'V', 'VIXM', 'VIXY', 'VOOG', 'VOOV', 'VOX', 'VTR', 'VTV', 'WELL', 'XLF', 'XLK', 'XLP', 'XLY'.
    """
    return rt.call_node('_node_wt_cash_equal_952', prices)

# region imports
from AlgorithmImports import *
# endregion
"""
Auto-generated from a Composer symphony's JSON score by symphony_codegen.py.
Do not hand-edit -- regenerate instead. See symphony_codegen.py's module
docstring for the schema-confidence caveats before trusting this.
"""
from typing import Dict, Sequence

import symphony_runtime as rt
import weathervane_part_0  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_1  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_2  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_3  # noqa: F401 -- registers this chunk's node functions
import weathervane_part_4  # noqa: F401 -- registers this chunk's node functions


def run_symphony(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    """Returns {ticker: target weight}. `prices` needs a chronological (oldest
    first) daily-close series for every ticker referenced below:
    'AAPX', 'AGG', 'AGQ', 'AMZN', 'AMZU', 'AMZZ', 'BABA', 'BAM', 'BIL', 'BITX', 'BN', 'BND', 'BTAL', 'BX', 'COIN', 'CONL', 'EDC', 'EDZ', 'EEM', 'FAS', 'FAZ', 'FBL', 'GDXD', 'GDXU', 'GGLL', 'GLD', 'HOOD', 'IBKR', 'IEF', 'IEI', 'IGIB', 'IOO', 'IUSV', 'IVW', 'IWM', 'KKR', 'KMLM', 'MA', 'META', 'NVDL', 'PLTR', 'PSQ', 'QLD', 'QQQ', 'QQQE', 'RGTI', 'SCHW', 'SH', 'SHV', 'SOFI', 'SOXL', 'SOXS', 'SPXL', 'SPY', 'SQQQ', 'SVIX', 'TECL', 'TECS', 'TLT', 'TMF', 'TQQQ', 'TSLA', 'TSLR', 'UGL', 'UPRO', 'UVXY', 'V', 'VIXM', 'VIXY', 'VOOG', 'VOOV', 'VOX', 'VTR', 'VTV', 'WELL', 'XLF', 'XLK', 'XLP', 'XLY'.
    """
    return rt.call_node('_node_wt_cash_equal_952', prices)

# region imports
from __future__ import annotations
from AlgorithmImports import *
import statistics
from typing import Callable, Dict, List, Optional, Sequence

# endregion
"""
Runtime support for code generated by the score-code generator: the indicator math
(`relative_strength_index`, `cumulative_return`, ...) and weight-combination helpers
that generated `_node_*` functions call into. Kept separate from the code generator
itself so the generated Python only has one small, readable import to depend on.

A price series is just `Sequence[float]`, chronological ascending (oldest first,
most recent/current last) -- e.g. daily closes. Every indicator function reads
backwards from the end of the series, consistent with how the strategy is evaluated
"as of today" using a trailing window.

Every name in INDICATOR_FUNCTIONS below is confirmed against 3 real strategies pulled
from a live account (not guessed) -- see the code generator's module docstring for how
and what's still unconfirmed (mainly: step/fn types those 3 strategies happen not to
use). Simple-average conventions, not Wilder-smoothed:
`relative_strength_index()` here averages gains/losses evenly over the window rather
than using Wilder's exponential smoothing, matching the same simplification
`ibkr_client.get_atr()` already makes for ATR elsewhere in this project (see that
function's docstring). The strategy's own engine may compute these indicators slightly
differently -- treat this as a reasonable approximation to sanity-check logic with, not
a bit-for-bit reproduction of the source backtester.
"""

# Deliberately not `from typing import Tuple`: QuantConnect Cloud's Python environment
# (used by the generated code when backtested via Lean) resolves a
# bare `Tuple` to .NET's System.Tuple via its interop stubs, colliding with typing's.
# `tuple[...]` (lowercase, PEP 585) is used in annotations below instead -- safe on any
# Python version because of `from __future__ import annotations` above.


def _window(prices: Sequence[float], window_days: int, extra: int = 0) -> Sequence[float]:
    """The trailing `window_days + extra` prices. `extra` is 1 for indicators that need
    one extra leading data point to compute `window_days` worth of day-over-day change
    (returns, RSI, drawdown)."""
    n = window_days + extra
    if len(prices) < n:
        raise ValueError(f"Need at least {n} price points for a {window_days}-day window, got {len(prices)}.")
    return prices[-n:]


def current_price(prices: Sequence[float], window_days: Optional[int] = None) -> float:
    """`window_days` accepted (and ignored) so every indicator function has the same
    `(prices, window_days)` signature -- simplifies the code generator's call sites."""
    if not prices:
        raise ValueError("Empty price series.")
    return float(prices[-1])


def cumulative_return(prices: Sequence[float], window_days: int) -> float:
    """Percent change from `window_days` ago to the most recent price."""
    w = _window(prices, window_days, extra=1)
    start, end = w[0], w[-1]
    return (end / start - 1.0) * 100.0


def moving_average_price(prices: Sequence[float], window_days: int) -> float:
    return statistics.fmean(_window(prices, window_days))


def moving_average_return(prices: Sequence[float], window_days: int) -> float:
    """Mean of day-over-day percent returns over the trailing window."""
    w = _window(prices, window_days, extra=1)
    returns = [(w[i] / w[i - 1] - 1.0) * 100.0 for i in range(1, len(w))]
    return statistics.fmean(returns)


def exponential_moving_average_price(prices: Sequence[float], window_days: int) -> float:
    """Standard EMA (alpha = 2/(window_days+1)), seeded with the simple average of the
    earliest `window_days` points then applied forward over whatever history is given
    (not just the trailing window -- EMA is defined recursively over the whole series)."""
    if len(prices) < window_days:
        raise ValueError(f"Need at least {window_days} price points, got {len(prices)}.")
    alpha = 2.0 / (window_days + 1)
    ema = statistics.fmean(prices[:window_days])
    for p in prices[window_days:]:
        ema = alpha * p + (1 - alpha) * ema
    return ema


def standard_deviation_price(prices: Sequence[float], window_days: int) -> float:
    return statistics.pstdev(_window(prices, window_days))


def standard_deviation_return(prices: Sequence[float], window_days: int) -> float:
    w = _window(prices, window_days, extra=1)
    returns = [(w[i] / w[i - 1] - 1.0) * 100.0 for i in range(1, len(w))]
    return statistics.pstdev(returns)


def relative_strength_index(prices: Sequence[float], window_days: int) -> float:
    """Relative Strength Index, 0-100. Simple (not Wilder-smoothed) average of
    gains/losses over the window -- see module docstring."""
    w = _window(prices, window_days, extra=1)
    changes = [w[i] - w[i - 1] for i in range(1, len(w))]
    gains = [c for c in changes if c > 0]
    losses = [-c for c in changes if c < 0]
    avg_gain = sum(gains) / window_days
    avg_loss = sum(losses) / window_days
    if avg_loss == 0:
        return 100.0 if avg_gain > 0 else 50.0
    rs = avg_gain / avg_loss
    return 100.0 - 100.0 / (1.0 + rs)


def max_drawdown(prices: Sequence[float], window_days: int) -> float:
    """Largest peak-to-trough decline over the trailing window, as a positive percent
    (e.g. 12.5 for a 12.5% drawdown)."""
    w = _window(prices, window_days, extra=1)
    peak = w[0]
    worst = 0.0
    for p in w:
        peak = max(peak, p)
        worst = max(worst, (peak - p) / peak)
    return worst * 100.0


INDICATOR_FUNCTIONS = {
    "current-price": current_price,
    "cumulative-return": cumulative_return,
    "moving-average-price": moving_average_price,
    "moving-average-return": moving_average_return,
    "exponential-moving-average-price": exponential_moving_average_price,
    "standard-deviation-price": standard_deviation_price,
    "standard-deviation-return": standard_deviation_return,
    "relative-strength-index": relative_strength_index,
    "max-drawdown": max_drawdown,
}
"""Maps the source's `lhs-fn`/`rhs-fn`/`sort-by-fn` node values to the functions above --
every key here is confirmed (all 9 appear across 3 real strategies pulled from a live
account), not guessed. A 4th strategy could still use an indicator these 3 happen not
to; extend this dict (and add a matching function above, named `fn.replace("-", "_")`)
if the code generator reports an fn name it doesn't recognize."""


COMPARATORS = {
    "gt": lambda a, b: a > b,
    "gte": lambda a, b: a >= b,
    "lt": lambda a, b: a < b,
    "lte": lambda a, b: a <= b,
}
"""The source's `comparator` node value -> a Python comparison. All 4 confirmed (seen
across 3 real strategies); the source may also have an "eq" or similar not observed here."""


def combine_equal(parts: List[Dict[str, float]]) -> Dict[str, float]:
    """Equal-weight combination of sibling subtrees' {ticker: weight} results (each
    summing to ~1.0 on its own) into one {ticker: weight} dict for their shared parent,
    also summing to ~1.0."""
    if not parts:
        return {}
    share = 1.0 / len(parts)
    result: Dict[str, float] = {}
    for part in parts:
        for ticker, weight in part.items():
            result[ticker] = result.get(ticker, 0.0) + weight * share
    return result


def combine_weighted(parts: List[tuple[float, Dict[str, float]]]) -> Dict[str, float]:
    """Like combine_equal(), but each (fraction, {ticker: weight}) pair carries its own
    explicit share (the source's per-child `weight: {num, den}`) instead of an equal 1/n."""
    result: Dict[str, float] = {}
    for fraction, part in parts:
        for ticker, weight in part.items():
            result[ticker] = result.get(ticker, 0.0) + weight * fraction
    return result


def combine_inverse_vol(parts: List[tuple[float, Dict[str, float]]]) -> Dict[str, float]:
    """Inverse-volatility weighting: each (volatility, {ticker: weight}) pair gets a
    share proportional to 1/volatility (higher volatility -> smaller share), normalized
    so shares sum to 1.0. `volatility` is typically standard_deviation_return() computed
    by the generated code for that child over the configured window.

    Approximation, not a confirmed reproduction of the source's own inverse-vol formula
    (e.g. the exact window/lookback used internally is not publicly documented
    as of when this was written) -- treat results as directional, verify against a real
    backtest before trusting exact weights.

    A zero (or negative, shouldn't happen) volatility is floored to a tiny epsilon
    rather than treated as literal infinity or as zero weight -- 1/vol is undefined at
    vol=0, but the *intent* of inverse-vol weighting is "the calmer the asset, the more
    weight it gets", so a perfectly flat price series should end up dominant, not
    excluded."""
    epsilon = 1e-9
    inv = [(1.0 / max(vol, epsilon), part) for vol, part in parts]
    total = sum(w for w, _ in inv)
    if total <= 0:
        return combine_equal([part for _, part in parts])
    result: Dict[str, float] = {}
    for weight, part in inv:
        fraction = weight / total
        for ticker, w in part.items():
            result[ticker] = result.get(ticker, 0.0) + w * fraction
    return result


def select_filter(
    scored: List[tuple[float, Dict[str, float]]], select_fn: str, n: int
) -> Dict[str, float]:
    """The source's 'filter' step: rank candidates by a score (each generated by the
    strategy's configured sort-by-fn/sort-by-fn-params, e.g. cumulative_return over some
    window -- on either a single asset's own price series, or, for a candidate that's a
    whole subtree, a synthetic_price_series() built from its resulting weights) and keep
    only the top or bottom `n`, equal-weighted. select-fn/select-n/sort-by-fn field names
    confirmed from 3 real strategies, but the exact weighting applied among
    multiple *selected* candidates when n > 1 is not separately confirmed; equal-weight
    is the standard convention and what's assumed here."""
    if select_fn == "top":
        ranked = sorted(scored, key=lambda pair: pair[0], reverse=True)
    elif select_fn == "bottom":
        ranked = sorted(scored, key=lambda pair: pair[0])
    else:
        raise ValueError(f"Unknown select-fn {select_fn!r} (expected 'top' or 'bottom').")
    chosen = [part for _, part in ranked[:n]]
    return combine_equal(chosen)


def synthetic_price_series(weights: Dict[str, float], prices: Dict[str, Sequence[float]]) -> List[float]:
    """Builds a synthetic blended price series for a sub-portfolio: each underlying
    ticker's price series is normalized to start at 1.0 over the shared trailing window
    (so different price scales don't distort the blend), then combined according to
    `weights` (e.g. a generated `_node_*` function's {ticker: weight} result, summing to
    ~1.0) into one NAV-style series.

    Used to rank or measure the volatility of a filter/wt-inverse-vol *candidate* that's
    a whole subtree rather than a single asset, confirmed to occur in real strategies
    (a 'filter' whose children are themselves conditional sub-strategies, not plain
    tickers). The source's own exact method for this isn't confirmed -- this is a
    standard, reasonable approximation (a weighted index of normalized prices), not a
    verified reproduction of its internal formula."""
    tickers = [t for t in weights if weights[t] != 0]
    if not tickers:
        raise ValueError("No non-zero-weight tickers to blend into a synthetic series.")
    length = min(len(prices[t]) for t in tickers)
    if length == 0:
        raise ValueError("No overlapping price history among the weighted tickers.")
    normalized = {t: [p / prices[t][-length] for p in prices[t][-length:]] for t in tickers}
    return [sum(weights[t] * normalized[t][i] for t in tickers) for i in range(length)]


NODE_REGISTRY: Dict[str, Callable[[Dict[str, Sequence[float]]], Dict[str, float]]] = {}
"""Populated by generated `_node_*` functions (see the code generator) as each one is
defined, so nodes can call each other via call_node() by name rather than by bare Python
reference. Needed because a large strategy's generated code can be split across multiple
files (some hosting platforms, notably QuantConnect Cloud, cap individual file size at
64,000 characters -- easily exceeded; a complex real strategy can generate 800,000+
characters of Python), and a plain function can only resolve a bare-name call to another
function defined in its own module, not a sibling file's -- a shared registry sidesteps
that entirely, at the cost of one dict lookup per node evaluated."""


def call_node(name: str, prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    fn = NODE_REGISTRY.get(name)
    if fn is None:
        raise KeyError(
            f"Node function {name!r} was called but never registered in NODE_REGISTRY -- "
            "its defining module wasn't imported before this call. For a multi-file "
            "generated strategy (see generate_python_chunks()), make "
            "sure every chunk module gets imported (even just for its registration side "
            "effect) before run_strategy() is called."
        )
    return fn(prices)

# region imports
from __future__ import annotations
from AlgorithmImports import *
import statistics
from typing import Callable, Dict, List, Optional, Sequence

# endregion
"""
Runtime support for code generated by `symphony_codegen.py`: the indicator math
(`relative_strength_index`, `cumulative_return`, ...) and weight-combination helpers
that generated `_node_*` functions call into. Kept separate from the code generator
itself so the generated Python only has one small, readable import to depend on.

A price series is just `Sequence[float]`, chronological ascending (oldest first,
most recent/current last) -- e.g. daily closes. Every indicator function reads
backwards from the end of the series, consistent with how Composer evaluates a
condition "as of today" using a trailing window.

Every name in INDICATOR_FUNCTIONS below is confirmed against 3 real symphonies pulled
from a live account (not guessed) -- see symphony_codegen.py's module docstring for how
and what's still unconfirmed (mainly: step/fn types those 3 symphonies happen not to
use). Simple-average conventions, not Wilder-smoothed:
`relative_strength_index()` here averages gains/losses evenly over the window rather
than using Wilder's exponential smoothing, matching the same simplification
`ibkr_client.get_atr()` already makes for ATR elsewhere in this project (see that
function's docstring). Composer's own engine may compute these indicators slightly
differently -- treat this as a reasonable approximation to sanity-check logic with, not
a bit-for-bit reproduction of Composer's backtester.
"""

# Deliberately not `from typing import Tuple`: QuantConnect Cloud's Python environment
# (used by symphony_codegen.py's generated code when backtested via Lean) resolves a
# bare `Tuple` to .NET's System.Tuple via its interop stubs, colliding with typing's.
# `tuple[...]` (lowercase, PEP 585) is used in annotations below instead -- safe on any
# Python version because of `from __future__ import annotations` above.


def _window(prices: Sequence[float], window_days: int, extra: int = 0) -> Sequence[float]:
    """The trailing `window_days + extra` prices. `extra` is 1 for indicators that need
    one extra leading data point to compute `window_days` worth of day-over-day change
    (returns, RSI, drawdown)."""
    n = window_days + extra
    if len(prices) < n:
        raise ValueError(f"Need at least {n} price points for a {window_days}-day window, got {len(prices)}.")
    return prices[-n:]


def current_price(prices: Sequence[float], window_days: Optional[int] = None) -> float:
    """`window_days` accepted (and ignored) so every indicator function has the same
    `(prices, window_days)` signature -- simplifies the code generator's call sites."""
    if not prices:
        raise ValueError("Empty price series.")
    return float(prices[-1])


def cumulative_return(prices: Sequence[float], window_days: int) -> float:
    """Percent change from `window_days` ago to the most recent price."""
    w = _window(prices, window_days, extra=1)
    start, end = w[0], w[-1]
    return (end / start - 1.0) * 100.0


def moving_average_price(prices: Sequence[float], window_days: int) -> float:
    return statistics.fmean(_window(prices, window_days))


def moving_average_return(prices: Sequence[float], window_days: int) -> float:
    """Mean of day-over-day percent returns over the trailing window."""
    w = _window(prices, window_days, extra=1)
    returns = [(w[i] / w[i - 1] - 1.0) * 100.0 for i in range(1, len(w))]
    return statistics.fmean(returns)


def exponential_moving_average_price(prices: Sequence[float], window_days: int) -> float:
    """Standard EMA (alpha = 2/(window_days+1)), seeded with the simple average of the
    earliest `window_days` points then applied forward over whatever history is given
    (not just the trailing window -- EMA is defined recursively over the whole series)."""
    if len(prices) < window_days:
        raise ValueError(f"Need at least {window_days} price points, got {len(prices)}.")
    alpha = 2.0 / (window_days + 1)
    ema = statistics.fmean(prices[:window_days])
    for p in prices[window_days:]:
        ema = alpha * p + (1 - alpha) * ema
    return ema


def standard_deviation_price(prices: Sequence[float], window_days: int) -> float:
    return statistics.pstdev(_window(prices, window_days))


def standard_deviation_return(prices: Sequence[float], window_days: int) -> float:
    w = _window(prices, window_days, extra=1)
    returns = [(w[i] / w[i - 1] - 1.0) * 100.0 for i in range(1, len(w))]
    return statistics.pstdev(returns)


def relative_strength_index(prices: Sequence[float], window_days: int) -> float:
    """Relative Strength Index, 0-100. Simple (not Wilder-smoothed) average of
    gains/losses over the window -- see module docstring."""
    w = _window(prices, window_days, extra=1)
    changes = [w[i] - w[i - 1] for i in range(1, len(w))]
    gains = [c for c in changes if c > 0]
    losses = [-c for c in changes if c < 0]
    avg_gain = sum(gains) / window_days
    avg_loss = sum(losses) / window_days
    if avg_loss == 0:
        return 100.0 if avg_gain > 0 else 50.0
    rs = avg_gain / avg_loss
    return 100.0 - 100.0 / (1.0 + rs)


def max_drawdown(prices: Sequence[float], window_days: int) -> float:
    """Largest peak-to-trough decline over the trailing window, as a positive percent
    (e.g. 12.5 for a 12.5% drawdown)."""
    w = _window(prices, window_days, extra=1)
    peak = w[0]
    worst = 0.0
    for p in w:
        peak = max(peak, p)
        worst = max(worst, (peak - p) / peak)
    return worst * 100.0


INDICATOR_FUNCTIONS = {
    "current-price": current_price,
    "cumulative-return": cumulative_return,
    "moving-average-price": moving_average_price,
    "moving-average-return": moving_average_return,
    "exponential-moving-average-price": exponential_moving_average_price,
    "standard-deviation-price": standard_deviation_price,
    "standard-deviation-return": standard_deviation_return,
    "relative-strength-index": relative_strength_index,
    "max-drawdown": max_drawdown,
}
"""Maps Composer's `lhs-fn`/`rhs-fn`/`sort-by-fn` node values to the functions above --
every key here is confirmed (all 9 appear across 3 real symphonies pulled from a live
account), not guessed. A 4th symphony could still use an indicator these 3 happen not
to; extend this dict (and add a matching function above, named `fn.replace("-", "_")`)
if symphony_codegen.py reports an fn name it doesn't recognize."""


COMPARATORS = {
    "gt": lambda a, b: a > b,
    "gte": lambda a, b: a >= b,
    "lt": lambda a, b: a < b,
    "lte": lambda a, b: a <= b,
}
"""Composer's `comparator` node value -> a Python comparison. All 4 confirmed (seen
across 3 real symphonies); Composer may also have an "eq" or similar not observed here."""


def combine_equal(parts: List[Dict[str, float]]) -> Dict[str, float]:
    """Equal-weight combination of sibling subtrees' {ticker: weight} results (each
    summing to ~1.0 on its own) into one {ticker: weight} dict for their shared parent,
    also summing to ~1.0."""
    if not parts:
        return {}
    share = 1.0 / len(parts)
    result: Dict[str, float] = {}
    for part in parts:
        for ticker, weight in part.items():
            result[ticker] = result.get(ticker, 0.0) + weight * share
    return result


def combine_weighted(parts: List[tuple[float, Dict[str, float]]]) -> Dict[str, float]:
    """Like combine_equal(), but each (fraction, {ticker: weight}) pair carries its own
    explicit share (Composer's per-child `weight: {num, den}`) instead of an equal 1/n."""
    result: Dict[str, float] = {}
    for fraction, part in parts:
        for ticker, weight in part.items():
            result[ticker] = result.get(ticker, 0.0) + weight * fraction
    return result


def combine_inverse_vol(parts: List[tuple[float, Dict[str, float]]]) -> Dict[str, float]:
    """Inverse-volatility weighting: each (volatility, {ticker: weight}) pair gets a
    share proportional to 1/volatility (higher volatility -> smaller share), normalized
    so shares sum to 1.0. `volatility` is typically standard_deviation_return() computed
    by the generated code for that child over Composer's configured window.

    Approximation, not a confirmed reproduction of Composer's own inverse-vol formula
    (e.g. the exact window/lookback Composer uses internally is not publicly documented
    as of when this was written) -- treat results as directional, verify against a real
    backtest before trusting exact weights.

    A zero (or negative, shouldn't happen) volatility is floored to a tiny epsilon
    rather than treated as literal infinity or as zero weight -- 1/vol is undefined at
    vol=0, but the *intent* of inverse-vol weighting is "the calmer the asset, the more
    weight it gets", so a perfectly flat price series should end up dominant, not
    excluded."""
    epsilon = 1e-9
    inv = [(1.0 / max(vol, epsilon), part) for vol, part in parts]
    total = sum(w for w, _ in inv)
    if total <= 0:
        return combine_equal([part for _, part in parts])
    result: Dict[str, float] = {}
    for weight, part in inv:
        fraction = weight / total
        for ticker, w in part.items():
            result[ticker] = result.get(ticker, 0.0) + w * fraction
    return result


def select_filter(
    scored: List[tuple[float, Dict[str, float]]], select_fn: str, n: int
) -> Dict[str, float]:
    """Composer's 'filter' step: rank candidates by a score (each generated by the
    symphony's configured sort-by-fn/sort-by-fn-params, e.g. cumulative_return over some
    window -- on either a single asset's own price series, or, for a candidate that's a
    whole subtree, a synthetic_price_series() built from its resulting weights) and keep
    only the top or bottom `n`, equal-weighted. select-fn/select-n/sort-by-fn field names
    confirmed from 3 real symphonies, but the exact weighting Composer applies among
    multiple *selected* candidates when n > 1 is not separately confirmed; equal-weight
    is the standard convention and what's assumed here."""
    if select_fn == "top":
        ranked = sorted(scored, key=lambda pair: pair[0], reverse=True)
    elif select_fn == "bottom":
        ranked = sorted(scored, key=lambda pair: pair[0])
    else:
        raise ValueError(f"Unknown select-fn {select_fn!r} (expected 'top' or 'bottom').")
    chosen = [part for _, part in ranked[:n]]
    return combine_equal(chosen)


def synthetic_price_series(weights: Dict[str, float], prices: Dict[str, Sequence[float]]) -> List[float]:
    """Builds a synthetic blended price series for a sub-portfolio: each underlying
    ticker's price series is normalized to start at 1.0 over the shared trailing window
    (so different price scales don't distort the blend), then combined according to
    `weights` (e.g. a generated `_node_*` function's {ticker: weight} result, summing to
    ~1.0) into one NAV-style series.

    Used to rank or measure the volatility of a filter/wt-inverse-vol *candidate* that's
    a whole subtree rather than a single asset, confirmed to occur in real symphonies
    (a 'filter' whose children are themselves conditional sub-strategies, not plain
    tickers). Composer's own exact method for this isn't confirmed -- this is a
    standard, reasonable approximation (a weighted index of normalized prices), not a
    verified reproduction of Composer's internal formula."""
    tickers = [t for t in weights if weights[t] != 0]
    if not tickers:
        raise ValueError("No non-zero-weight tickers to blend into a synthetic series.")
    length = min(len(prices[t]) for t in tickers)
    if length == 0:
        raise ValueError("No overlapping price history among the weighted tickers.")
    normalized = {t: [p / prices[t][-length] for p in prices[t][-length:]] for t in tickers}
    return [sum(weights[t] * normalized[t][i] for t in tickers) for i in range(length)]


NODE_REGISTRY: Dict[str, Callable[[Dict[str, Sequence[float]]], Dict[str, float]]] = {}
"""Populated by generated `_node_*` functions (see symphony_codegen.py) as each one is
defined, so nodes can call each other via call_node() by name rather than by bare Python
reference. Needed because a large symphony's generated code can be split across multiple
files (some hosting platforms, notably QuantConnect Cloud, cap individual file size at
64,000 characters -- easily exceeded; a complex real symphony can generate 800,000+
characters of Python), and a plain function can only resolve a bare-name call to another
function defined in its own module, not a sibling file's -- a shared registry sidesteps
that entirely, at the cost of one dict lookup per node evaluated."""


def call_node(name: str, prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    fn = NODE_REGISTRY.get(name)
    if fn is None:
        raise KeyError(
            f"Node function {name!r} was called but never registered in NODE_REGISTRY -- "
            "its defining module wasn't imported before this call. For a multi-file "
            "generated symphony (see symphony_codegen.generate_python_chunks()), make "
            "sure every chunk module gets imported (even just for its registration side "
            "effect) before run_symphony() is called."
        )
    return fn(prices)

# region imports
from AlgorithmImports import *
# endregion
from typing import Dict, Sequence

import strategy_runtime as rt


def _node_asset_UVXY_1(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_1'] = _node_asset_UVXY_1


def _node_asset_UVXY_2(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_2'] = _node_asset_UVXY_2


def _node_asset_TQQQ_3(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_3'] = _node_asset_TQQQ_3


def _node_wt_cash_equal_4(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_TQQQ_3', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_4'] = _node_wt_cash_equal_4


def _node_if_5(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPXL'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_2', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_4', prices)
rt.NODE_REGISTRY['_node_if_5'] = _node_if_5


def _node_wt_cash_equal_6(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_5', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_6'] = _node_wt_cash_equal_6


def _node_if_7(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_1', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_6', prices)
rt.NODE_REGISTRY['_node_if_7'] = _node_if_7


def _node_wt_cash_equal_8(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_7', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_8'] = _node_wt_cash_equal_8


def _node_asset_TECL_9(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_9'] = _node_asset_TECL_9


def _node_asset_UPRO_10(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UPRO': 1.0}
rt.NODE_REGISTRY['_node_asset_UPRO_10'] = _node_asset_UPRO_10


def _node_asset_SQQQ_11(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_11'] = _node_asset_SQQQ_11


def _node_asset_TLT_12(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TLT': 1.0}
rt.NODE_REGISTRY['_node_asset_TLT_12'] = _node_asset_TLT_12


def _node_filter_13(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_11', prices)), (rt.relative_strength_index(prices['TLT'], 10), rt.call_node('_node_asset_TLT_12', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_13'] = _node_filter_13


def _node_wt_cash_equal_14(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_13', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_14'] = _node_wt_cash_equal_14


def _node_asset_SQQQ_15(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_15'] = _node_asset_SQQQ_15


def _node_asset_TQQQ_16(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_16'] = _node_asset_TQQQ_16


def _node_if_17(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SQQQ'], 10) < 31.0:
        return rt.call_node('_node_asset_SQQQ_15', prices)
    else:
        return rt.call_node('_node_asset_TQQQ_16', prices)
rt.NODE_REGISTRY['_node_if_17'] = _node_if_17


def _node_wt_cash_equal_18(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_17', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_18'] = _node_wt_cash_equal_18


def _node_if_19(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TQQQ']) < rt.moving_average_price(prices['TQQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_14', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_18', prices)
rt.NODE_REGISTRY['_node_if_19'] = _node_if_19


def _node_wt_cash_equal_20(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_19', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_20'] = _node_wt_cash_equal_20


def _node_if_21(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_asset_UPRO_10', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_20', prices)
rt.NODE_REGISTRY['_node_if_21'] = _node_if_21


def _node_wt_cash_equal_22(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_21', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_22'] = _node_wt_cash_equal_22


def _node_if_23(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) < 31.0:
        return rt.call_node('_node_asset_TECL_9', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_22', prices)
rt.NODE_REGISTRY['_node_if_23'] = _node_if_23


def _node_wt_cash_equal_24(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_23', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_24'] = _node_wt_cash_equal_24


def _node_if_25(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_8', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_24', prices)
rt.NODE_REGISTRY['_node_if_25'] = _node_if_25


def _node_wt_cash_equal_26(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_25', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_26'] = _node_wt_cash_equal_26


def _node_wt_cash_equal_27(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_26', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_27'] = _node_wt_cash_equal_27


def _node_asset_EDC_28(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_28'] = _node_asset_EDC_28


def _node_asset_BIL_29(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_29'] = _node_asset_BIL_29


def _node_wt_cash_specified_30(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('68') / float(100)), rt.call_node('_node_asset_EDC_28', prices)), ((float(32) / float(100)), rt.call_node('_node_asset_BIL_29', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_30'] = _node_wt_cash_specified_30


def _node_asset_EDC_31(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_31'] = _node_asset_EDC_31


def _node_asset_EDZ_32(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_32'] = _node_asset_EDZ_32


def _node_if_33(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEI'], 10) > rt.relative_strength_index(prices['IWM'], 15):
        return rt.call_node('_node_asset_EDC_31', prices)
    else:
        return rt.call_node('_node_asset_EDZ_32', prices)
rt.NODE_REGISTRY['_node_if_33'] = _node_if_33


def _node_wt_cash_equal_34(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_33', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_34'] = _node_wt_cash_equal_34


def _node_asset_EDC_35(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_35'] = _node_asset_EDC_35


def _node_asset_EDZ_36(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_36'] = _node_asset_EDZ_36


def _node_if_37(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 15) > rt.relative_strength_index(prices['EEM'], 15):
        return rt.call_node('_node_asset_EDC_35', prices)
    else:
        return rt.call_node('_node_asset_EDZ_36', prices)
rt.NODE_REGISTRY['_node_if_37'] = _node_if_37


def _node_wt_cash_equal_38(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_37', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_38'] = _node_wt_cash_equal_38


def _node_asset_EDC_39(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_39'] = _node_asset_EDC_39


def _node_asset_EDZ_40(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_40'] = _node_asset_EDZ_40


def _node_if_41(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EDC_39', prices)
    else:
        return rt.call_node('_node_asset_EDZ_40', prices)
rt.NODE_REGISTRY['_node_if_41'] = _node_if_41


def _node_wt_cash_equal_42(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_41', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_42'] = _node_wt_cash_equal_42


def _node_combine_equal_43(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_38', prices), rt.call_node('_node_wt_cash_equal_42', prices)])
rt.NODE_REGISTRY['_node_combine_equal_43'] = _node_combine_equal_43


def _node_if_44(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['EEM']) > rt.moving_average_price(prices['EEM'], 200):
        return rt.call_node('_node_wt_cash_equal_34', prices)
    else:
        return rt.call_node('_node_combine_equal_43', prices)
rt.NODE_REGISTRY['_node_if_44'] = _node_if_44


def _node_wt_cash_equal_45(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_44', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_45'] = _node_wt_cash_equal_45


def _node_asset_EDC_46(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_46'] = _node_asset_EDC_46


def _node_asset_EDZ_47(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_47'] = _node_asset_EDZ_47


def _node_if_48(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EDC_46', prices)
    else:
        return rt.call_node('_node_asset_EDZ_47', prices)
rt.NODE_REGISTRY['_node_if_48'] = _node_if_48


def _node_wt_cash_equal_49(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_48', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_49'] = _node_wt_cash_equal_49


def _node_if_50(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SHV']) > rt.moving_average_price(prices['SHV'], 50):
        return rt.call_node('_node_wt_cash_equal_45', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_49', prices)
rt.NODE_REGISTRY['_node_if_50'] = _node_if_50


def _node_wt_cash_equal_51(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_50', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_51'] = _node_wt_cash_equal_51


def _node_if_52(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['EEM'], 10) < 25.0:
        return rt.call_node('_node_wt_cash_specified_30', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_51', prices)
rt.NODE_REGISTRY['_node_if_52'] = _node_if_52


def _node_wt_cash_equal_53(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_52', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_53'] = _node_wt_cash_equal_53


def _node_wt_cash_equal_54(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_53', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_54'] = _node_wt_cash_equal_54


def _node_asset_EDC_55(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_55'] = _node_asset_EDC_55


def _node_asset_BIL_56(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_56'] = _node_asset_BIL_56


def _node_wt_cash_specified_57(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('68') / float(100)), rt.call_node('_node_asset_EDC_55', prices)), ((float(32) / float(100)), rt.call_node('_node_asset_BIL_56', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_57'] = _node_wt_cash_specified_57


def _node_asset_EEM_58(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_58'] = _node_asset_EEM_58


def _node_asset_EDZ_59(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_59'] = _node_asset_EDZ_59


def _node_asset_BIL_60(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_60'] = _node_asset_BIL_60


def _node_wt_cash_specified_61(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_59', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_60', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_61'] = _node_wt_cash_specified_61


def _node_if_62(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEI'], 10) > rt.relative_strength_index(prices['IWM'], 15):
        return rt.call_node('_node_asset_EEM_58', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_61', prices)
rt.NODE_REGISTRY['_node_if_62'] = _node_if_62


def _node_wt_cash_equal_63(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_62', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_63'] = _node_wt_cash_equal_63


def _node_asset_EEM_64(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_64'] = _node_asset_EEM_64


def _node_asset_EDZ_65(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_65'] = _node_asset_EDZ_65


def _node_asset_BIL_66(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_66'] = _node_asset_BIL_66


def _node_wt_cash_specified_67(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_65', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_66', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_67'] = _node_wt_cash_specified_67


def _node_if_68(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 15) > rt.relative_strength_index(prices['EEM'], 15):
        return rt.call_node('_node_asset_EEM_64', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_67', prices)
rt.NODE_REGISTRY['_node_if_68'] = _node_if_68


def _node_wt_cash_equal_69(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_68', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_69'] = _node_wt_cash_equal_69


def _node_asset_EEM_70(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_70'] = _node_asset_EEM_70


def _node_asset_EDZ_71(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_71'] = _node_asset_EDZ_71


def _node_asset_BIL_72(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_72'] = _node_asset_BIL_72


def _node_wt_cash_specified_73(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_71', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_72', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_73'] = _node_wt_cash_specified_73


def _node_if_74(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EEM_70', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_73', prices)
rt.NODE_REGISTRY['_node_if_74'] = _node_if_74


def _node_wt_cash_equal_75(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_74', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_75'] = _node_wt_cash_equal_75


def _node_combine_equal_76(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_69', prices), rt.call_node('_node_wt_cash_equal_75', prices)])
rt.NODE_REGISTRY['_node_combine_equal_76'] = _node_combine_equal_76


def _node_if_77(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['EEM']) > rt.moving_average_price(prices['EEM'], 200):
        return rt.call_node('_node_wt_cash_equal_63', prices)
    else:
        return rt.call_node('_node_combine_equal_76', prices)
rt.NODE_REGISTRY['_node_if_77'] = _node_if_77


def _node_wt_cash_equal_78(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_77', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_78'] = _node_wt_cash_equal_78


def _node_asset_EEM_79(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_79'] = _node_asset_EEM_79


def _node_asset_EDZ_80(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_80'] = _node_asset_EDZ_80


def _node_asset_BIL_81(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_81'] = _node_asset_BIL_81


def _node_wt_cash_specified_82(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_80', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_81', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_82'] = _node_wt_cash_specified_82


def _node_if_83(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EEM_79', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_82', prices)
rt.NODE_REGISTRY['_node_if_83'] = _node_if_83


def _node_wt_cash_equal_84(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_83', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_84'] = _node_wt_cash_equal_84


def _node_if_85(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SHV']) > rt.moving_average_price(prices['SHV'], 50):
        return rt.call_node('_node_wt_cash_equal_78', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_84', prices)
rt.NODE_REGISTRY['_node_if_85'] = _node_if_85


def _node_wt_cash_equal_86(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_85', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_86'] = _node_wt_cash_equal_86


def _node_if_87(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['EEM'], 10) < 25.0:
        return rt.call_node('_node_wt_cash_specified_57', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_86', prices)
rt.NODE_REGISTRY['_node_if_87'] = _node_if_87


def _node_wt_cash_equal_88(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_87', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_88'] = _node_wt_cash_equal_88


def _node_wt_cash_equal_89(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_88', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_89'] = _node_wt_cash_equal_89


def _node_if_90(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_54', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_89', prices)
rt.NODE_REGISTRY['_node_if_90'] = _node_if_90


def _node_wt_cash_equal_91(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_90', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_91'] = _node_wt_cash_equal_91


def _node_wt_cash_equal_92(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_91', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_92'] = _node_wt_cash_equal_92


def _node_asset_UVXY_93(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_93'] = _node_asset_UVXY_93


def _node_asset_UVXY_94(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_94'] = _node_asset_UVXY_94


def _node_asset_UVXY_95(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_95'] = _node_asset_UVXY_95


def _node_asset_UVXY_96(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_96'] = _node_asset_UVXY_96


def _node_asset_UVXY_97(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_97'] = _node_asset_UVXY_97


def _node_asset_UVXY_98(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_98'] = _node_asset_UVXY_98


def _node_asset_UVXY_99(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_99'] = _node_asset_UVXY_99


def _node_asset_UVXY_100(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_100'] = _node_asset_UVXY_100


def _node_wt_cash_equal_101(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_UVXY_100', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_101'] = _node_wt_cash_equal_101


def _node_asset_UVXY_102(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_102'] = _node_asset_UVXY_102


def _node_asset_UVXY_103(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_103'] = _node_asset_UVXY_103


def _node_asset_UVXY_104(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_104'] = _node_asset_UVXY_104


def _node_asset_VIXM_105(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VIXM': 1.0}
rt.NODE_REGISTRY['_node_asset_VIXM_105'] = _node_asset_VIXM_105


def _node_asset_SPXL_106(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SPXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SPXL_106'] = _node_asset_SPXL_106


def _node_if_107(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 21) > 30.0:
        return rt.call_node('_node_asset_VIXM_105', prices)
    else:
        return rt.call_node('_node_asset_SPXL_106', prices)
rt.NODE_REGISTRY['_node_if_107'] = _node_if_107


def _node_wt_cash_equal_108(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_107', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_108'] = _node_wt_cash_equal_108


def _node_wt_cash_equal_109(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_108', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_109'] = _node_wt_cash_equal_109


def _node_asset_TECL_110(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_110'] = _node_asset_TECL_110


def _node_asset_SOXL_111(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_111'] = _node_asset_SOXL_111


def _node_asset_SPXL_112(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SPXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SPXL_112'] = _node_asset_SPXL_112


def _node_asset_TECL_113(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_113'] = _node_asset_TECL_113


def _node_asset_SOXL_114(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_114'] = _node_asset_SOXL_114


def _node_filter_115(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['TECL'], 10), rt.call_node('_node_asset_TECL_113', prices)), (rt.relative_strength_index(prices['SOXL'], 10), rt.call_node('_node_asset_SOXL_114', prices))], 'bottom', int('1'))
rt.NODE_REGISTRY['_node_filter_115'] = _node_filter_115


def _node_wt_cash_equal_116(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_115', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_116'] = _node_wt_cash_equal_116


def _node_asset_SQQQ_117(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_117'] = _node_asset_SQQQ_117


def _node_asset_TLT_118(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TLT': 1.0}
rt.NODE_REGISTRY['_node_asset_TLT_118'] = _node_asset_TLT_118


def _node_filter_119(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_117', prices)), (rt.relative_strength_index(prices['TLT'], 10), rt.call_node('_node_asset_TLT_118', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_119'] = _node_filter_119


def _node_wt_cash_equal_120(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_119', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_120'] = _node_wt_cash_equal_120


def _node_if_121(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLK'], 10) > rt.relative_strength_index(prices['KMLM'], 10):
        return rt.call_node('_node_wt_cash_equal_116', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_120', prices)
rt.NODE_REGISTRY['_node_if_121'] = _node_if_121


def _node_wt_cash_equal_122(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_121', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_122'] = _node_wt_cash_equal_122


def _node_wt_cash_equal_123(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_122', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_123'] = _node_wt_cash_equal_123


def _node_wt_cash_equal_124(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_123', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_124'] = _node_wt_cash_equal_124


def _node_if_125(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPXL'], 10) < 30.0:
        return rt.call_node('_node_asset_SPXL_112', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_124', prices)
rt.NODE_REGISTRY['_node_if_125'] = _node_if_125


def _node_wt_cash_equal_126(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_125', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_126'] = _node_wt_cash_equal_126


def _node_if_127(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SOXL'], 10) < 30.0:
        return rt.call_node('_node_asset_SOXL_111', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_126', prices)
rt.NODE_REGISTRY['_node_if_127'] = _node_if_127


def _node_wt_cash_equal_128(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_127', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_128'] = _node_wt_cash_equal_128


def _node_if_129(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) < 30.0:
        return rt.call_node('_node_asset_TECL_110', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_128', prices)
rt.NODE_REGISTRY['_node_if_129'] = _node_if_129


def _node_wt_cash_equal_130(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_129', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_130'] = _node_wt_cash_equal_130


def _node_wt_cash_equal_131(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_130', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_131'] = _node_wt_cash_equal_131


def _node_if_132(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 21) > 65.0:
        return rt.call_node('_node_wt_cash_equal_109', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_131', prices)
rt.NODE_REGISTRY['_node_if_132'] = _node_if_132


def _node_wt_cash_equal_133(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_132', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_133'] = _node_wt_cash_equal_133


def _node_wt_cash_equal_134(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_133', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_134'] = _node_wt_cash_equal_134


def _node_if_135(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_104', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_134', prices)
rt.NODE_REGISTRY['_node_if_135'] = _node_if_135


def _node_wt_cash_equal_136(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_135', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_136'] = _node_wt_cash_equal_136


def _node_if_137(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['FAS'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_103', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_136', prices)
rt.NODE_REGISTRY['_node_if_137'] = _node_if_137


def _node_wt_cash_equal_138(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_137', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_138'] = _node_wt_cash_equal_138


def _node_if_139(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLY'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_102', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_138', prices)
rt.NODE_REGISTRY['_node_if_139'] = _node_if_139


def _node_wt_cash_equal_140(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_139', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_140'] = _node_wt_cash_equal_140


def _node_if_141(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_101', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_140', prices)
rt.NODE_REGISTRY['_node_if_141'] = _node_if_141


def _node_wt_cash_equal_142(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_141', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_142'] = _node_wt_cash_equal_142


def _node_if_143(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 75.0:
        return rt.call_node('_node_asset_UVXY_99', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_142', prices)
rt.NODE_REGISTRY['_node_if_143'] = _node_if_143


def _node_wt_cash_equal_144(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_143', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_144'] = _node_wt_cash_equal_144


def _node_if_145(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VOOV'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_98', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_144', prices)
rt.NODE_REGISTRY['_node_if_145'] = _node_if_145


def _node_wt_cash_equal_146(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_145', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_146'] = _node_wt_cash_equal_146


def _node_if_147(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VOOG'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_97', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_146', prices)
rt.NODE_REGISTRY['_node_if_147'] = _node_if_147


def _node_wt_cash_equal_148(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_147', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_148'] = _node_wt_cash_equal_148


def _node_if_149(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TECL'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_96', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_148', prices)
rt.NODE_REGISTRY['_node_if_149'] = _node_if_149


def _node_wt_cash_equal_150(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_149', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_150'] = _node_wt_cash_equal_150


def _node_if_151(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VOX'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_95', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_150', prices)
rt.NODE_REGISTRY['_node_if_151'] = _node_if_151


def _node_wt_cash_equal_152(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_151', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_152'] = _node_wt_cash_equal_152


def _node_if_153(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_94', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_152', prices)
rt.NODE_REGISTRY['_node_if_153'] = _node_if_153


def _node_wt_cash_equal_154(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_153', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_154'] = _node_wt_cash_equal_154


def _node_if_155(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQE'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_93', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_154', prices)
rt.NODE_REGISTRY['_node_if_155'] = _node_if_155


def _node_wt_cash_equal_156(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_155', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_156'] = _node_wt_cash_equal_156


def _node_wt_cash_equal_157(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_156', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_157'] = _node_wt_cash_equal_157


def _node_asset_GDXD_158(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXD': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXD_158'] = _node_asset_GDXD_158


def _node_asset_UGL_159(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UGL': 1.0}
rt.NODE_REGISTRY['_node_asset_UGL_159'] = _node_asset_UGL_159


def _node_asset_UGL_160(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UGL': 1.0}
rt.NODE_REGISTRY['_node_asset_UGL_160'] = _node_asset_UGL_160


def _node_asset_BIL_161(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_161'] = _node_asset_BIL_161


def _node_if_162(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['UGL'], 70) < rt.cumulative_return(prices['UGL'], 75):
        return rt.call_node('_node_asset_UGL_160', prices)
    else:
        return rt.call_node('_node_asset_BIL_161', prices)
rt.NODE_REGISTRY['_node_if_162'] = _node_if_162


def _node_wt_cash_equal_163(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_162', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_163'] = _node_wt_cash_equal_163


def _node_asset_GDXD_164(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXD': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXD_164'] = _node_asset_GDXD_164


def _node_asset_BIL_165(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_165'] = _node_asset_BIL_165


def _node_if_166(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['TLT'], 95) < rt.cumulative_return(prices['QQQ'], 35):
        return rt.call_node('_node_asset_GDXD_164', prices)
    else:
        return rt.call_node('_node_asset_BIL_165', prices)
rt.NODE_REGISTRY['_node_if_166'] = _node_if_166


def _node_wt_cash_equal_167(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_166', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_167'] = _node_wt_cash_equal_167


def _node_if_168(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['QQQ'], 90) > rt.cumulative_return(prices['QQQ'], 70):
        return rt.call_node('_node_wt_cash_equal_163', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_167', prices)
rt.NODE_REGISTRY['_node_if_168'] = _node_if_168


def _node_wt_cash_equal_169(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_168', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_169'] = _node_wt_cash_equal_169


def _node_if_170(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UGL'], 10) < 30.0:
        return rt.call_node('_node_asset_UGL_159', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_169', prices)
rt.NODE_REGISTRY['_node_if_170'] = _node_if_170


def _node_wt_cash_equal_171(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_170', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_171'] = _node_wt_cash_equal_171


def _node_if_172(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UGL'], 10) > 79.0:
        return rt.call_node('_node_asset_GDXD_158', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_171', prices)
rt.NODE_REGISTRY['_node_if_172'] = _node_if_172


def _node_wt_cash_equal_173(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_172', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_173'] = _node_wt_cash_equal_173


def _node_asset_SOXL_174(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_174'] = _node_asset_SOXL_174


def _node_asset_SOXL_175(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_175'] = _node_asset_SOXL_175


def _node_asset_SOXL_176(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_176'] = _node_asset_SOXL_176


def _node_asset_SOXL_177(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_177'] = _node_asset_SOXL_177


def _node_asset_SOXL_178(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_178'] = _node_asset_SOXL_178


def _node_asset_UVXY_179(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_179'] = _node_asset_UVXY_179


def _node_asset_UVXY_180(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_180'] = _node_asset_UVXY_180


def _node_wt_cash_equal_181(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_UVXY_180', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_181'] = _node_wt_cash_equal_181


def _node_asset_UVXY_182(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_182'] = _node_asset_UVXY_182


def _node_asset_UVXY_183(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_183'] = _node_asset_UVXY_183


def _node_asset_UVXY_184(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_184'] = _node_asset_UVXY_184


def _node_asset_UVXY_185(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_185'] = _node_asset_UVXY_185


def _node_asset_UVXY_186(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_186'] = _node_asset_UVXY_186


def _node_asset_UVXY_187(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_187'] = _node_asset_UVXY_187


def _node_asset_VIXY_188(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VIXY': 1.0}
rt.NODE_REGISTRY['_node_asset_VIXY_188'] = _node_asset_VIXY_188


def _node_asset_VIXY_189(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VIXY': 1.0}
rt.NODE_REGISTRY['_node_asset_VIXY_189'] = _node_asset_VIXY_189


def _node_asset_VIXY_190(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VIXY': 1.0}
rt.NODE_REGISTRY['_node_asset_VIXY_190'] = _node_asset_VIXY_190


def _node_asset_SOXL_191(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_191'] = _node_asset_SOXL_191


def _node_asset_UVXY_192(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_192'] = _node_asset_UVXY_192


def _node_asset_TMF_193(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TMF': 1.0}
rt.NODE_REGISTRY['_node_asset_TMF_193'] = _node_asset_TMF_193


def _node_asset_SOXL_194(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_194'] = _node_asset_SOXL_194


def _node_wt_cash_equal_195(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_194', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_195'] = _node_wt_cash_equal_195


def _node_asset_SOXL_196(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_196'] = _node_asset_SOXL_196


def _node_wt_cash_equal_197(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_196', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_197'] = _node_wt_cash_equal_197


def _node_asset_SOXL_198(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_198'] = _node_asset_SOXL_198


def _node_wt_cash_equal_199(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_198', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_199'] = _node_wt_cash_equal_199


def _node_asset_SOXL_200(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_200'] = _node_asset_SOXL_200


def _node_wt_cash_equal_201(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_200', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_201'] = _node_wt_cash_equal_201


def _node_asset_UPRO_202(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UPRO': 1.0}
rt.NODE_REGISTRY['_node_asset_UPRO_202'] = _node_asset_UPRO_202


def _node_asset_TQQQ_203(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_203'] = _node_asset_TQQQ_203


def _node_wt_cash_specified_204(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('80') / float(100)), rt.call_node('_node_asset_UPRO_202', prices)), ((float(20) / float(100)), rt.call_node('_node_asset_TQQQ_203', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_204'] = _node_wt_cash_specified_204


def _node_if_205(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 31.0:
        return rt.call_node('_node_wt_cash_equal_201', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_204', prices)
rt.NODE_REGISTRY['_node_if_205'] = _node_if_205


def _node_wt_cash_equal_206(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_205', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_206'] = _node_wt_cash_equal_206


def _node_if_207(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 31.0:
        return rt.call_node('_node_wt_cash_equal_199', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_206', prices)
rt.NODE_REGISTRY['_node_if_207'] = _node_if_207


def _node_wt_cash_equal_208(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_207', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_208'] = _node_wt_cash_equal_208


def _node_if_209(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 99.0:
        return rt.call_node('_node_wt_cash_equal_197', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_208', prices)
rt.NODE_REGISTRY['_node_if_209'] = _node_if_209


def _node_wt_cash_equal_210(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_209', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_210'] = _node_wt_cash_equal_210


def _node_if_211(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 56.0:
        return rt.call_node('_node_wt_cash_equal_195', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_210', prices)
rt.NODE_REGISTRY['_node_if_211'] = _node_if_211


def _node_wt_cash_equal_212(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_211', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_212'] = _node_wt_cash_equal_212


def _node_if_213(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -16.0:
        return rt.call_node('_node_asset_TMF_193', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_212', prices)
rt.NODE_REGISTRY['_node_if_213'] = _node_if_213


def _node_wt_cash_equal_214(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_213', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_214'] = _node_wt_cash_equal_214


def _node_if_215(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -20.0:
        return rt.call_node('_node_asset_UVXY_192', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_214', prices)
rt.NODE_REGISTRY['_node_if_215'] = _node_if_215


def _node_wt_cash_equal_216(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_215', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_216'] = _node_wt_cash_equal_216


def _node_if_217(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -25.0:
        return rt.call_node('_node_asset_SOXL_191', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_216', prices)
rt.NODE_REGISTRY['_node_if_217'] = _node_if_217


def _node_wt_cash_equal_218(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_217', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_218'] = _node_wt_cash_equal_218


def _node_if_219(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 200) > 57.0:
        return rt.call_node('_node_asset_VIXY_190', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_218', prices)
rt.NODE_REGISTRY['_node_if_219'] = _node_if_219


def _node_wt_cash_equal_220(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_219', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_220'] = _node_wt_cash_equal_220


def _node_wt_cash_equal_221(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_220', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_221'] = _node_wt_cash_equal_221


def _node_if_222(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 63.0:
        return rt.call_node('_node_asset_VIXY_189', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_221', prices)
rt.NODE_REGISTRY['_node_if_222'] = _node_if_222


def _node_wt_cash_equal_223(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_222', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_223'] = _node_wt_cash_equal_223


def _node_if_224(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 14) > 99.0:
        return rt.call_node('_node_asset_VIXY_188', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_223', prices)
rt.NODE_REGISTRY['_node_if_224'] = _node_if_224


def _node_wt_cash_equal_225(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_224', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_225'] = _node_wt_cash_equal_225


def _node_if_226(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 60) > 67.0:
        return rt.call_node('_node_asset_UVXY_187', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_225', prices)
rt.NODE_REGISTRY['_node_if_226'] = _node_if_226


def _node_wt_cash_equal_227(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_226', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_227'] = _node_wt_cash_equal_227


def _node_if_228(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 68.0:
        return rt.call_node('_node_asset_UVXY_186', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_227', prices)
rt.NODE_REGISTRY['_node_if_228'] = _node_if_228


def _node_wt_cash_equal_229(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_228', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_229'] = _node_wt_cash_equal_229


def _node_if_230(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 6) > 86.0:
        return rt.call_node('_node_asset_UVXY_185', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_229', prices)
rt.NODE_REGISTRY['_node_if_230'] = _node_if_230


def _node_wt_cash_equal_231(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_230', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_231'] = _node_wt_cash_equal_231


def _node_if_232(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 5) > 92.0:
        return rt.call_node('_node_asset_UVXY_184', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_231', prices)
rt.NODE_REGISTRY['_node_if_232'] = _node_if_232


def _node_wt_cash_equal_233(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_232', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_233'] = _node_wt_cash_equal_233


def _node_if_234(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 5) > 88.0:
        return rt.call_node('_node_asset_UVXY_183', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_233', prices)
rt.NODE_REGISTRY['_node_if_234'] = _node_if_234


def _node_wt_cash_equal_235(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_234', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_235'] = _node_wt_cash_equal_235


def _node_if_236(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_182', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_235', prices)
rt.NODE_REGISTRY['_node_if_236'] = _node_if_236


def _node_wt_cash_equal_237(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_236', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_237'] = _node_wt_cash_equal_237

# region imports
from AlgorithmImports import *
# endregion
from typing import Dict, Sequence

import strategy_runtime as rt


def _node_if_238(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_181', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_237', prices)
rt.NODE_REGISTRY['_node_if_238'] = _node_if_238


def _node_wt_cash_equal_239(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_238', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_239'] = _node_wt_cash_equal_239


def _node_if_240(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 77.0:
        return rt.call_node('_node_asset_UVXY_179', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_239', prices)
rt.NODE_REGISTRY['_node_if_240'] = _node_if_240


def _node_wt_cash_specified_241(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float(100) / float(100)), rt.call_node('_node_if_240', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_241'] = _node_wt_cash_specified_241


def _node_if_242(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 84.0:
        return rt.call_node('_node_asset_SOXL_178', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_241', prices)
rt.NODE_REGISTRY['_node_if_242'] = _node_if_242


def _node_wt_cash_equal_243(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_242', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_243'] = _node_wt_cash_equal_243


def _node_asset_SOXL_244(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_244'] = _node_asset_SOXL_244


def _node_asset_UVXY_245(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_245'] = _node_asset_UVXY_245


def _node_asset_UVXY_246(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_246'] = _node_asset_UVXY_246


def _node_asset_UVXY_247(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_247'] = _node_asset_UVXY_247


def _node_asset_UVXY_248(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_248'] = _node_asset_UVXY_248


def _node_asset_UVXY_249(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_249'] = _node_asset_UVXY_249


def _node_asset_UVXY_250(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_250'] = _node_asset_UVXY_250


def _node_asset_UVXY_251(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_251'] = _node_asset_UVXY_251


def _node_asset_SOXL_252(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_252'] = _node_asset_SOXL_252


def _node_wt_cash_equal_253(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_252', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_253'] = _node_wt_cash_equal_253


def _node_asset_UVXY_254(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_254'] = _node_asset_UVXY_254


def _node_asset_SOXL_255(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_255'] = _node_asset_SOXL_255


def _node_if_256(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) < 84.0:
        return rt.call_node('_node_asset_UVXY_254', prices)
    else:
        return rt.call_node('_node_asset_SOXL_255', prices)
rt.NODE_REGISTRY['_node_if_256'] = _node_if_256


def _node_wt_cash_equal_257(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_256', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_257'] = _node_wt_cash_equal_257


def _node_asset_SOXL_258(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_258'] = _node_asset_SOXL_258


def _node_wt_cash_equal_259(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_258', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_259'] = _node_wt_cash_equal_259


def _node_asset_SOXL_260(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_260'] = _node_asset_SOXL_260


def _node_wt_cash_equal_261(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_260', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_261'] = _node_wt_cash_equal_261


def _node_asset_SQQQ_262(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_262'] = _node_asset_SQQQ_262


def _node_wt_cash_equal_263(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SQQQ_262', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_263'] = _node_wt_cash_equal_263


def _node_asset_SOXL_264(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_264'] = _node_asset_SOXL_264


def _node_wt_cash_equal_265(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_264', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_265'] = _node_wt_cash_equal_265


def _node_if_266(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) < 33.0:
        return rt.call_node('_node_wt_cash_equal_263', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_265', prices)
rt.NODE_REGISTRY['_node_if_266'] = _node_if_266


def _node_wt_cash_equal_267(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_266', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_267'] = _node_wt_cash_equal_267


def _node_asset_SOXL_268(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_268'] = _node_asset_SOXL_268


def _node_wt_cash_equal_269(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_268', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_269'] = _node_wt_cash_equal_269


def _node_asset_SOXL_270(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_270'] = _node_asset_SOXL_270


def _node_wt_cash_equal_271(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_270', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_271'] = _node_wt_cash_equal_271


def _node_asset_SOXL_272(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_272'] = _node_asset_SOXL_272


def _node_wt_cash_equal_273(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_272', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_273'] = _node_wt_cash_equal_273


def _node_asset_GLD_274(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GLD': 1.0}
rt.NODE_REGISTRY['_node_asset_GLD_274'] = _node_asset_GLD_274


def _node_if_275(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > rt.relative_strength_index(prices['TLT'], 10):
        return rt.call_node('_node_wt_cash_equal_273', prices)
    else:
        return rt.call_node('_node_asset_GLD_274', prices)
rt.NODE_REGISTRY['_node_if_275'] = _node_if_275


def _node_wt_cash_equal_276(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_275', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_276'] = _node_wt_cash_equal_276


def _node_asset_SQQQ_277(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_277'] = _node_asset_SQQQ_277


def _node_filter_278(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_277', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_278'] = _node_filter_278


def _node_wt_cash_equal_279(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_278', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_279'] = _node_wt_cash_equal_279


def _node_asset_TMF_280(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TMF': 1.0}
rt.NODE_REGISTRY['_node_asset_TMF_280'] = _node_asset_TMF_280


def _node_asset_TQQQ_281(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_281'] = _node_asset_TQQQ_281


def _node_wt_cash_equal_282(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_TQQQ_281', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_282'] = _node_wt_cash_equal_282


def _node_if_283(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TLT']) > rt.moving_average_price(prices['TLT'], 200):
        return rt.call_node('_node_asset_TMF_280', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_282', prices)
rt.NODE_REGISTRY['_node_if_283'] = _node_if_283


def _node_wt_cash_equal_284(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_283', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_284'] = _node_wt_cash_equal_284


def _node_if_285(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) > rt.relative_strength_index(prices['TLT'], 10):
        return rt.call_node('_node_wt_cash_equal_279', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_284', prices)
rt.NODE_REGISTRY['_node_if_285'] = _node_if_285


def _node_wt_cash_equal_286(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_285', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_286'] = _node_wt_cash_equal_286


def _node_if_287(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) > 65.0:
        return rt.call_node('_node_wt_cash_equal_276', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_286', prices)
rt.NODE_REGISTRY['_node_if_287'] = _node_if_287


def _node_wt_cash_equal_288(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_287', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_288'] = _node_wt_cash_equal_288


def _node_wt_cash_equal_289(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_288', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_289'] = _node_wt_cash_equal_289


def _node_if_290(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 30):
        return rt.call_node('_node_wt_cash_equal_271', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_289', prices)
rt.NODE_REGISTRY['_node_if_290'] = _node_if_290


def _node_wt_cash_equal_291(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_290', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_291'] = _node_wt_cash_equal_291


def _node_if_292(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 31.0:
        return rt.call_node('_node_wt_cash_equal_269', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_291', prices)
rt.NODE_REGISTRY['_node_if_292'] = _node_if_292


def _node_wt_cash_equal_293(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_292', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_293'] = _node_wt_cash_equal_293


def _node_if_294(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['QQQ']) > rt.moving_average_price(prices['QQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_267', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_293', prices)
rt.NODE_REGISTRY['_node_if_294'] = _node_if_294


def _node_wt_cash_equal_295(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_294', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_295'] = _node_wt_cash_equal_295


def _node_if_296(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_261', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_295', prices)
rt.NODE_REGISTRY['_node_if_296'] = _node_if_296


def _node_wt_cash_equal_297(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_296', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_297'] = _node_wt_cash_equal_297


def _node_if_298(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 28.0:
        return rt.call_node('_node_wt_cash_equal_259', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_297', prices)
rt.NODE_REGISTRY['_node_if_298'] = _node_if_298


def _node_wt_cash_equal_299(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_298', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_299'] = _node_wt_cash_equal_299


def _node_if_300(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 74.0:
        return rt.call_node('_node_wt_cash_equal_257', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_299', prices)
rt.NODE_REGISTRY['_node_if_300'] = _node_if_300


def _node_wt_cash_equal_301(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_300', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_301'] = _node_wt_cash_equal_301


def _node_if_302(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 18.0:
        return rt.call_node('_node_wt_cash_equal_253', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_301', prices)
rt.NODE_REGISTRY['_node_if_302'] = _node_if_302


def _node_wt_cash_equal_303(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_302', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_303'] = _node_wt_cash_equal_303


def _node_if_304(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -24.0:
        return rt.call_node('_node_asset_UVXY_251', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_303', prices)
rt.NODE_REGISTRY['_node_if_304'] = _node_if_304


def _node_wt_cash_equal_305(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_304', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_305'] = _node_wt_cash_equal_305


def _node_if_306(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 52.0:
        return rt.call_node('_node_asset_UVXY_250', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_305', prices)
rt.NODE_REGISTRY['_node_if_306'] = _node_if_306


def _node_wt_cash_equal_307(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_306', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_307'] = _node_wt_cash_equal_307


def _node_if_308(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 60) > 55.0:
        return rt.call_node('_node_asset_UVXY_249', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_307', prices)
rt.NODE_REGISTRY['_node_if_308'] = _node_if_308


def _node_wt_cash_equal_309(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_308', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_309'] = _node_wt_cash_equal_309


def _node_if_310(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 6) > 78.0:
        return rt.call_node('_node_asset_UVXY_248', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_309', prices)
rt.NODE_REGISTRY['_node_if_310'] = _node_if_310


def _node_wt_cash_equal_311(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_310', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_311'] = _node_wt_cash_equal_311


def _node_if_312(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 77.0:
        return rt.call_node('_node_asset_UVXY_247', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_311', prices)
rt.NODE_REGISTRY['_node_if_312'] = _node_if_312


def _node_wt_cash_equal_313(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_312', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_313'] = _node_wt_cash_equal_313


def _node_if_314(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 72.0:
        return rt.call_node('_node_asset_UVXY_246', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_313', prices)
rt.NODE_REGISTRY['_node_if_314'] = _node_if_314


def _node_wt_cash_equal_315(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_314', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_315'] = _node_wt_cash_equal_315


def _node_if_316(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 76.0:
        return rt.call_node('_node_asset_UVXY_245', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_315', prices)
rt.NODE_REGISTRY['_node_if_316'] = _node_if_316


def _node_wt_cash_equal_317(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_316', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_317'] = _node_wt_cash_equal_317


def _node_if_318(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 84.0:
        return rt.call_node('_node_asset_SOXL_244', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_317', prices)
rt.NODE_REGISTRY['_node_if_318'] = _node_if_318


def _node_wt_cash_equal_319(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_318', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_319'] = _node_wt_cash_equal_319


def _node_if_320(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_243', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_319', prices)
rt.NODE_REGISTRY['_node_if_320'] = _node_if_320


def _node_wt_cash_equal_321(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_320', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_321'] = _node_wt_cash_equal_321


def _node_if_322(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 5) < -57.0:
        return rt.call_node('_node_asset_SOXL_177', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_321', prices)
rt.NODE_REGISTRY['_node_if_322'] = _node_if_322


def _node_wt_cash_equal_323(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_322', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_323'] = _node_wt_cash_equal_323


def _node_if_324(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 2) < -37.0:
        return rt.call_node('_node_asset_SOXL_176', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_323', prices)
rt.NODE_REGISTRY['_node_if_324'] = _node_if_324


def _node_wt_cash_equal_325(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_324', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_325'] = _node_wt_cash_equal_325


def _node_if_326(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -31.0:
        return rt.call_node('_node_asset_SOXL_175', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_325', prices)
rt.NODE_REGISTRY['_node_if_326'] = _node_if_326


def _node_wt_cash_equal_327(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_326', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_327'] = _node_wt_cash_equal_327


def _node_if_328(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['QQQ'], 10) < -2.4:
        return rt.call_node('_node_asset_SOXL_174', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_327', prices)
rt.NODE_REGISTRY['_node_if_328'] = _node_if_328


def _node_wt_cash_equal_329(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_328', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_329'] = _node_wt_cash_equal_329


def _node_wt_cash_equal_330(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_329', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_330'] = _node_wt_cash_equal_330


def _node_wt_cash_equal_331(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_27', prices), rt.call_node('_node_wt_cash_equal_92', prices), rt.call_node('_node_wt_cash_equal_157', prices), rt.call_node('_node_wt_cash_equal_173', prices), rt.call_node('_node_wt_cash_equal_330', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_331'] = _node_wt_cash_equal_331


def _node_asset_GDXD_332(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXD': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXD_332'] = _node_asset_GDXD_332


def _node_asset_GDXU_333(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXU': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXU_333'] = _node_asset_GDXU_333


def _node_asset_GDXU_334(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXU': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXU_334'] = _node_asset_GDXU_334


def _node_asset_UVXY_335(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_335'] = _node_asset_UVXY_335


def _node_asset_UVXY_336(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_336'] = _node_asset_UVXY_336


def _node_asset_UVXY_337(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_337'] = _node_asset_UVXY_337


def _node_asset_UVXY_338(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_338'] = _node_asset_UVXY_338


def _node_asset_UVXY_339(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_339'] = _node_asset_UVXY_339


def _node_asset_UVXY_340(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_340'] = _node_asset_UVXY_340


def _node_asset_UVXY_341(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_341'] = _node_asset_UVXY_341


def _node_asset_UVXY_342(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_342'] = _node_asset_UVXY_342


def _node_asset_BIL_343(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_343'] = _node_asset_BIL_343


def _node_asset_BTAL_344(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_344'] = _node_asset_BTAL_344


def _node_wt_cash_equal_345(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_343', prices), rt.call_node('_node_asset_BTAL_344', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_345'] = _node_wt_cash_equal_345


def _node_wt_cash_specified_346(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('75') / float(100)), rt.call_node('_node_asset_UVXY_342', prices)), ((float('25') / float(100)), rt.call_node('_node_wt_cash_equal_345', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_346'] = _node_wt_cash_specified_346


def _node_if_347(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_341', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_346', prices)
rt.NODE_REGISTRY['_node_if_347'] = _node_if_347


def _node_wt_cash_equal_348(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_347', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_348'] = _node_wt_cash_equal_348


def _node_if_349(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_340', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_348', prices)
rt.NODE_REGISTRY['_node_if_349'] = _node_if_349


def _node_wt_cash_equal_350(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_349', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_350'] = _node_wt_cash_equal_350


def _node_if_351(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_339', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_350', prices)
rt.NODE_REGISTRY['_node_if_351'] = _node_if_351


def _node_wt_cash_equal_352(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_351', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_352'] = _node_wt_cash_equal_352


def _node_if_353(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IOO'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_338', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_352', prices)
rt.NODE_REGISTRY['_node_if_353'] = _node_if_353


def _node_wt_cash_equal_354(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_353', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_354'] = _node_wt_cash_equal_354


def _node_if_355(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_337', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_354', prices)
rt.NODE_REGISTRY['_node_if_355'] = _node_if_355


def _node_wt_cash_equal_356(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_355', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_356'] = _node_wt_cash_equal_356


def _node_asset_UVXY_357(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_357'] = _node_asset_UVXY_357


def _node_asset_UVXY_358(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_358'] = _node_asset_UVXY_358


def _node_asset_UVXY_359(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_359'] = _node_asset_UVXY_359


def _node_asset_UVXY_360(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_360'] = _node_asset_UVXY_360


def _node_asset_UVXY_361(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_361'] = _node_asset_UVXY_361


def _node_asset_BIL_362(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_362'] = _node_asset_BIL_362


def _node_asset_BTAL_363(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_363'] = _node_asset_BTAL_363


def _node_wt_cash_equal_364(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_362', prices), rt.call_node('_node_asset_BTAL_363', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_364'] = _node_wt_cash_equal_364


def _node_wt_cash_specified_365(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('75') / float(100)), rt.call_node('_node_asset_UVXY_361', prices)), ((float('25') / float(100)), rt.call_node('_node_wt_cash_equal_364', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_365'] = _node_wt_cash_specified_365


def _node_if_366(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_360', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_365', prices)
rt.NODE_REGISTRY['_node_if_366'] = _node_if_366


def _node_wt_cash_equal_367(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_366', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_367'] = _node_wt_cash_equal_367


def _node_if_368(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_359', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_367', prices)
rt.NODE_REGISTRY['_node_if_368'] = _node_if_368


def _node_wt_cash_equal_369(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_368', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_369'] = _node_wt_cash_equal_369


def _node_if_370(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_358', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_369', prices)
rt.NODE_REGISTRY['_node_if_370'] = _node_if_370


def _node_wt_cash_equal_371(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_370', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_371'] = _node_wt_cash_equal_371


def _node_if_372(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IOO'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_357', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_371', prices)
rt.NODE_REGISTRY['_node_if_372'] = _node_if_372


def _node_wt_cash_equal_373(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_372', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_373'] = _node_wt_cash_equal_373


def _node_asset_UVXY_374(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_374'] = _node_asset_UVXY_374


def _node_asset_UVXY_375(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_375'] = _node_asset_UVXY_375


def _node_asset_UVXY_376(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_376'] = _node_asset_UVXY_376


def _node_asset_UVXY_377(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_377'] = _node_asset_UVXY_377


def _node_asset_BIL_378(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_378'] = _node_asset_BIL_378


def _node_asset_BTAL_379(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_379'] = _node_asset_BTAL_379


def _node_wt_cash_equal_380(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_378', prices), rt.call_node('_node_asset_BTAL_379', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_380'] = _node_wt_cash_equal_380


def _node_wt_cash_specified_381(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('75') / float(100)), rt.call_node('_node_asset_UVXY_377', prices)), ((float('25') / float(100)), rt.call_node('_node_wt_cash_equal_380', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_381'] = _node_wt_cash_specified_381


def _node_if_382(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_376', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_381', prices)
rt.NODE_REGISTRY['_node_if_382'] = _node_if_382


def _node_wt_cash_equal_383(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_382', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_383'] = _node_wt_cash_equal_383


def _node_if_384(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_375', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_383', prices)
rt.NODE_REGISTRY['_node_if_384'] = _node_if_384


def _node_wt_cash_equal_385(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_384', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_385'] = _node_wt_cash_equal_385


def _node_if_386(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_374', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_385', prices)
rt.NODE_REGISTRY['_node_if_386'] = _node_if_386


def _node_wt_cash_equal_387(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_386', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_387'] = _node_wt_cash_equal_387


def _node_asset_UVXY_388(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_388'] = _node_asset_UVXY_388


def _node_asset_UVXY_389(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_389'] = _node_asset_UVXY_389


def _node_asset_UVXY_390(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_390'] = _node_asset_UVXY_390


def _node_asset_BIL_391(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_391'] = _node_asset_BIL_391


def _node_asset_BTAL_392(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_392'] = _node_asset_BTAL_392


def _node_wt_cash_equal_393(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_391', prices), rt.call_node('_node_asset_BTAL_392', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_393'] = _node_wt_cash_equal_393


def _node_wt_cash_specified_394(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('75') / float(100)), rt.call_node('_node_asset_UVXY_390', prices)), ((float('25') / float(100)), rt.call_node('_node_wt_cash_equal_393', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_394'] = _node_wt_cash_specified_394


def _node_if_395(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_389', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_394', prices)
rt.NODE_REGISTRY['_node_if_395'] = _node_if_395


def _node_wt_cash_equal_396(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_395', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_396'] = _node_wt_cash_equal_396


def _node_if_397(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_388', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_396', prices)
rt.NODE_REGISTRY['_node_if_397'] = _node_if_397


def _node_wt_cash_equal_398(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_397', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_398'] = _node_wt_cash_equal_398


def _node_asset_UVXY_399(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_399'] = _node_asset_UVXY_399


def _node_asset_UVXY_400(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_400'] = _node_asset_UVXY_400


def _node_asset_BIL_401(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_401'] = _node_asset_BIL_401


def _node_asset_BTAL_402(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_402'] = _node_asset_BTAL_402


def _node_wt_cash_equal_403(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_401', prices), rt.call_node('_node_asset_BTAL_402', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_403'] = _node_wt_cash_equal_403


def _node_wt_cash_specified_404(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('75') / float(100)), rt.call_node('_node_asset_UVXY_400', prices)), ((float('25') / float(100)), rt.call_node('_node_wt_cash_equal_403', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_404'] = _node_wt_cash_specified_404


def _node_if_405(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 81.0:
        return rt.call_node('_node_asset_UVXY_399', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_404', prices)
rt.NODE_REGISTRY['_node_if_405'] = _node_if_405


def _node_wt_cash_equal_406(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_405', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_406'] = _node_wt_cash_equal_406


def _node_asset_TQQQ_407(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_407'] = _node_asset_TQQQ_407


def _node_asset_SPXL_408(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SPXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SPXL_408'] = _node_asset_SPXL_408


def _node_asset_AAPX_409(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AAPX': 1.0}
rt.NODE_REGISTRY['_node_asset_AAPX_409'] = _node_asset_AAPX_409


def _node_asset_BIL_410(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_410'] = _node_asset_BIL_410


def _node_asset_TQQQ_411(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_411'] = _node_asset_TQQQ_411


def _node_combine_equal_412(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_410', prices), rt.call_node('_node_asset_TQQQ_411', prices)])
rt.NODE_REGISTRY['_node_combine_equal_412'] = _node_combine_equal_412


def _node_if_413(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['AAPX'], 10) > 0.0:
        return rt.call_node('_node_asset_AAPX_409', prices)
    else:
        return rt.call_node('_node_combine_equal_412', prices)
rt.NODE_REGISTRY['_node_if_413'] = _node_if_413


def _node_wt_cash_equal_414(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_413', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_414'] = _node_wt_cash_equal_414


def _node_asset_NVDL_415(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'NVDL': 1.0}
rt.NODE_REGISTRY['_node_asset_NVDL_415'] = _node_asset_NVDL_415


def _node_asset_BIL_416(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_416'] = _node_asset_BIL_416


def _node_asset_TQQQ_417(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_417'] = _node_asset_TQQQ_417


def _node_combine_equal_418(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_416', prices), rt.call_node('_node_asset_TQQQ_417', prices)])
rt.NODE_REGISTRY['_node_combine_equal_418'] = _node_combine_equal_418


def _node_if_419(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['NVDL'], 10) > 0.0:
        return rt.call_node('_node_asset_NVDL_415', prices)
    else:
        return rt.call_node('_node_combine_equal_418', prices)
rt.NODE_REGISTRY['_node_if_419'] = _node_if_419


def _node_wt_cash_equal_420(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_419', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_420'] = _node_wt_cash_equal_420


def _node_asset_BITX_421(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BITX': 1.0}
rt.NODE_REGISTRY['_node_asset_BITX_421'] = _node_asset_BITX_421


def _node_asset_BIL_422(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_422'] = _node_asset_BIL_422


def _node_asset_TQQQ_423(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_423'] = _node_asset_TQQQ_423


def _node_combine_equal_424(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_422', prices), rt.call_node('_node_asset_TQQQ_423', prices)])
rt.NODE_REGISTRY['_node_combine_equal_424'] = _node_combine_equal_424


def _node_if_425(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['BITX'], 10) > 0.0:
        return rt.call_node('_node_asset_BITX_421', prices)
    else:
        return rt.call_node('_node_combine_equal_424', prices)
rt.NODE_REGISTRY['_node_if_425'] = _node_if_425


def _node_wt_cash_equal_426(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_425', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_426'] = _node_wt_cash_equal_426


def _node_asset_TSLR_427(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TSLR': 1.0}
rt.NODE_REGISTRY['_node_asset_TSLR_427'] = _node_asset_TSLR_427


def _node_asset_BIL_428(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_428'] = _node_asset_BIL_428


def _node_asset_TQQQ_429(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_429'] = _node_asset_TQQQ_429


def _node_combine_equal_430(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_428', prices), rt.call_node('_node_asset_TQQQ_429', prices)])
rt.NODE_REGISTRY['_node_combine_equal_430'] = _node_combine_equal_430


def _node_if_431(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['TSLA'], 10) > 0.0:
        return rt.call_node('_node_asset_TSLR_427', prices)
    else:
        return rt.call_node('_node_combine_equal_430', prices)
rt.NODE_REGISTRY['_node_if_431'] = _node_if_431


def _node_wt_cash_equal_432(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_431', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_432'] = _node_wt_cash_equal_432


def _node_asset_FBL_433(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FBL': 1.0}
rt.NODE_REGISTRY['_node_asset_FBL_433'] = _node_asset_FBL_433


def _node_asset_BIL_434(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_434'] = _node_asset_BIL_434


def _node_asset_TQQQ_435(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_435'] = _node_asset_TQQQ_435


def _node_combine_equal_436(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_434', prices), rt.call_node('_node_asset_TQQQ_435', prices)])
rt.NODE_REGISTRY['_node_combine_equal_436'] = _node_combine_equal_436


def _node_if_437(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['META'], 10) > 0.0:
        return rt.call_node('_node_asset_FBL_433', prices)
    else:
        return rt.call_node('_node_combine_equal_436', prices)
rt.NODE_REGISTRY['_node_if_437'] = _node_if_437


def _node_wt_cash_equal_438(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_437', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_438'] = _node_wt_cash_equal_438


def _node_asset_GGLL_439(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GGLL': 1.0}
rt.NODE_REGISTRY['_node_asset_GGLL_439'] = _node_asset_GGLL_439


def _node_asset_BIL_440(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_440'] = _node_asset_BIL_440


def _node_asset_TQQQ_441(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_441'] = _node_asset_TQQQ_441


def _node_combine_equal_442(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_440', prices), rt.call_node('_node_asset_TQQQ_441', prices)])
rt.NODE_REGISTRY['_node_combine_equal_442'] = _node_combine_equal_442


def _node_if_443(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['GGLL'], 10) > 0.0:
        return rt.call_node('_node_asset_GGLL_439', prices)
    else:
        return rt.call_node('_node_combine_equal_442', prices)
rt.NODE_REGISTRY['_node_if_443'] = _node_if_443


def _node_wt_cash_equal_444(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_443', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_444'] = _node_wt_cash_equal_444


def _node_asset_AMZU_445(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AMZU': 1.0}
rt.NODE_REGISTRY['_node_asset_AMZU_445'] = _node_asset_AMZU_445


def _node_asset_BIL_446(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_446'] = _node_asset_BIL_446


def _node_asset_TQQQ_447(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_447'] = _node_asset_TQQQ_447


def _node_combine_equal_448(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_446', prices), rt.call_node('_node_asset_TQQQ_447', prices)])
rt.NODE_REGISTRY['_node_combine_equal_448'] = _node_combine_equal_448


def _node_if_449(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['AMZN'], 10) > 0.0:
        return rt.call_node('_node_asset_AMZU_445', prices)
    else:
        return rt.call_node('_node_combine_equal_448', prices)
rt.NODE_REGISTRY['_node_if_449'] = _node_if_449


def _node_wt_cash_equal_450(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_449', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_450'] = _node_wt_cash_equal_450


def _node_asset_RGTI_451(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'RGTI': 1.0}
rt.NODE_REGISTRY['_node_asset_RGTI_451'] = _node_asset_RGTI_451


def _node_asset_BIL_452(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_452'] = _node_asset_BIL_452


def _node_asset_TQQQ_453(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_453'] = _node_asset_TQQQ_453


def _node_combine_equal_454(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_452', prices), rt.call_node('_node_asset_TQQQ_453', prices)])
rt.NODE_REGISTRY['_node_combine_equal_454'] = _node_combine_equal_454


def _node_if_455(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['RGTI'], 10) > 0.0:
        return rt.call_node('_node_asset_RGTI_451', prices)
    else:
        return rt.call_node('_node_combine_equal_454', prices)
rt.NODE_REGISTRY['_node_if_455'] = _node_if_455


def _node_wt_cash_equal_456(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_455', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_456'] = _node_wt_cash_equal_456


def _node_asset_PLTR_457(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PLTR': 1.0}
rt.NODE_REGISTRY['_node_asset_PLTR_457'] = _node_asset_PLTR_457


def _node_asset_BIL_458(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_458'] = _node_asset_BIL_458


def _node_asset_TQQQ_459(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_459'] = _node_asset_TQQQ_459


def _node_combine_equal_460(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_458', prices), rt.call_node('_node_asset_TQQQ_459', prices)])
rt.NODE_REGISTRY['_node_combine_equal_460'] = _node_combine_equal_460


def _node_if_461(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['PLTR'], 10) > 0.0:
        return rt.call_node('_node_asset_PLTR_457', prices)
    else:
        return rt.call_node('_node_combine_equal_460', prices)
rt.NODE_REGISTRY['_node_if_461'] = _node_if_461


def _node_wt_cash_equal_462(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_461', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_462'] = _node_wt_cash_equal_462


def _node_asset_BABA_463(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BABA': 1.0}
rt.NODE_REGISTRY['_node_asset_BABA_463'] = _node_asset_BABA_463


def _node_asset_BIL_464(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_464'] = _node_asset_BIL_464


def _node_asset_TQQQ_465(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_465'] = _node_asset_TQQQ_465


def _node_combine_equal_466(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_464', prices), rt.call_node('_node_asset_TQQQ_465', prices)])
rt.NODE_REGISTRY['_node_combine_equal_466'] = _node_combine_equal_466


def _node_if_467(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['BABA'], 10) > 0.0:
        return rt.call_node('_node_asset_BABA_463', prices)
    else:
        return rt.call_node('_node_combine_equal_466', prices)
rt.NODE_REGISTRY['_node_if_467'] = _node_if_467


def _node_wt_cash_equal_468(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_467', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_468'] = _node_wt_cash_equal_468


def _node_asset_CONL_469(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'CONL': 1.0}
rt.NODE_REGISTRY['_node_asset_CONL_469'] = _node_asset_CONL_469


def _node_asset_BIL_470(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_470'] = _node_asset_BIL_470


def _node_asset_TQQQ_471(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_471'] = _node_asset_TQQQ_471


def _node_combine_equal_472(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_BIL_470', prices), rt.call_node('_node_asset_TQQQ_471', prices)])
rt.NODE_REGISTRY['_node_combine_equal_472'] = _node_combine_equal_472


def _node_if_473(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['COIN'], 10) > 0.0:
        return rt.call_node('_node_asset_CONL_469', prices)
    else:
        return rt.call_node('_node_combine_equal_472', prices)
rt.NODE_REGISTRY['_node_if_473'] = _node_if_473


def _node_wt_cash_equal_474(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_473', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_474'] = _node_wt_cash_equal_474

# region imports
from AlgorithmImports import *
# endregion
from typing import Dict, Sequence

import strategy_runtime as rt


def _node_filter_475(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_414', prices), prices), 20), rt.call_node('_node_wt_cash_equal_414', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_420', prices), prices), 20), rt.call_node('_node_wt_cash_equal_420', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_426', prices), prices), 20), rt.call_node('_node_wt_cash_equal_426', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_432', prices), prices), 20), rt.call_node('_node_wt_cash_equal_432', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_438', prices), prices), 20), rt.call_node('_node_wt_cash_equal_438', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_444', prices), prices), 20), rt.call_node('_node_wt_cash_equal_444', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_450', prices), prices), 20), rt.call_node('_node_wt_cash_equal_450', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_456', prices), prices), 20), rt.call_node('_node_wt_cash_equal_456', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_462', prices), prices), 20), rt.call_node('_node_wt_cash_equal_462', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_468', prices), prices), 20), rt.call_node('_node_wt_cash_equal_468', prices)), (rt.standard_deviation_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_474', prices), prices), 20), rt.call_node('_node_wt_cash_equal_474', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_475'] = _node_filter_475


def _node_wt_cash_equal_476(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_475', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_476'] = _node_wt_cash_equal_476


def _node_asset_AAPX_477(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AAPX': 1.0}
rt.NODE_REGISTRY['_node_asset_AAPX_477'] = _node_asset_AAPX_477


def _node_asset_NVDL_478(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'NVDL': 1.0}
rt.NODE_REGISTRY['_node_asset_NVDL_478'] = _node_asset_NVDL_478


def _node_asset_BITX_479(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BITX': 1.0}
rt.NODE_REGISTRY['_node_asset_BITX_479'] = _node_asset_BITX_479


def _node_asset_TSLR_480(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TSLR': 1.0}
rt.NODE_REGISTRY['_node_asset_TSLR_480'] = _node_asset_TSLR_480


def _node_asset_FBL_481(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FBL': 1.0}
rt.NODE_REGISTRY['_node_asset_FBL_481'] = _node_asset_FBL_481


def _node_asset_GGLL_482(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GGLL': 1.0}
rt.NODE_REGISTRY['_node_asset_GGLL_482'] = _node_asset_GGLL_482


def _node_asset_AMZZ_483(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AMZZ': 1.0}
rt.NODE_REGISTRY['_node_asset_AMZZ_483'] = _node_asset_AMZZ_483


def _node_asset_RGTI_484(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'RGTI': 1.0}
rt.NODE_REGISTRY['_node_asset_RGTI_484'] = _node_asset_RGTI_484


def _node_asset_PLTR_485(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PLTR': 1.0}
rt.NODE_REGISTRY['_node_asset_PLTR_485'] = _node_asset_PLTR_485


def _node_asset_BABA_486(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BABA': 1.0}
rt.NODE_REGISTRY['_node_asset_BABA_486'] = _node_asset_BABA_486


def _node_asset_CONL_487(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'CONL': 1.0}
rt.NODE_REGISTRY['_node_asset_CONL_487'] = _node_asset_CONL_487


def _node_filter_488(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.moving_average_return(prices['AAPX'], 15), rt.call_node('_node_asset_AAPX_477', prices)), (rt.moving_average_return(prices['NVDL'], 15), rt.call_node('_node_asset_NVDL_478', prices)), (rt.moving_average_return(prices['BITX'], 15), rt.call_node('_node_asset_BITX_479', prices)), (rt.moving_average_return(prices['TSLR'], 15), rt.call_node('_node_asset_TSLR_480', prices)), (rt.moving_average_return(prices['FBL'], 15), rt.call_node('_node_asset_FBL_481', prices)), (rt.moving_average_return(prices['GGLL'], 15), rt.call_node('_node_asset_GGLL_482', prices)), (rt.moving_average_return(prices['AMZZ'], 15), rt.call_node('_node_asset_AMZZ_483', prices)), (rt.moving_average_return(prices['RGTI'], 15), rt.call_node('_node_asset_RGTI_484', prices)), (rt.moving_average_return(prices['PLTR'], 15), rt.call_node('_node_asset_PLTR_485', prices)), (rt.moving_average_return(prices['BABA'], 15), rt.call_node('_node_asset_BABA_486', prices)), (rt.moving_average_return(prices['CONL'], 15), rt.call_node('_node_asset_CONL_487', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_488'] = _node_filter_488


def _node_wt_cash_equal_489(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_488', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_489'] = _node_wt_cash_equal_489


def _node_asset_TECS_490(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECS': 1.0}
rt.NODE_REGISTRY['_node_asset_TECS_490'] = _node_asset_TECS_490


def _node_asset_SOXS_491(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXS': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXS_491'] = _node_asset_SOXS_491


def _node_asset_SQQQ_492(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_492'] = _node_asset_SQQQ_492


def _node_wt_cash_equal_493(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_TECS_490', prices), rt.call_node('_node_asset_SOXS_491', prices), rt.call_node('_node_asset_SQQQ_492', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_493'] = _node_wt_cash_equal_493


def _node_if_494(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['KMLM']) < rt.moving_average_price(prices['KMLM'], 20):
        return rt.call_node('_node_wt_cash_equal_489', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_493', prices)
rt.NODE_REGISTRY['_node_if_494'] = _node_if_494


def _node_wt_cash_equal_495(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_494', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_495'] = _node_wt_cash_equal_495


def _node_wt_cash_equal_496(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_495', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_496'] = _node_wt_cash_equal_496


def _node_if_497(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLK'], 10) > rt.relative_strength_index(prices['KMLM'], 10):
        return rt.call_node('_node_wt_cash_equal_476', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_496', prices)
rt.NODE_REGISTRY['_node_if_497'] = _node_if_497


def _node_wt_cash_equal_498(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_497', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_498'] = _node_wt_cash_equal_498


def _node_asset_QQQ_499(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'QQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_QQQ_499'] = _node_asset_QQQ_499


def _node_wt_cash_equal_500(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_QQQ_499', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_500'] = _node_wt_cash_equal_500


def _node_asset_PSQ_501(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_501'] = _node_asset_PSQ_501


def _node_asset_TQQQ_502(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_502'] = _node_asset_TQQQ_502


def _node_asset_PSQ_503(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_503'] = _node_asset_PSQ_503


def _node_if_504(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['AGG'], 20) > rt.relative_strength_index(prices['SH'], 60):
        return rt.call_node('_node_asset_TQQQ_502', prices)
    else:
        return rt.call_node('_node_asset_PSQ_503', prices)
rt.NODE_REGISTRY['_node_if_504'] = _node_if_504


def _node_wt_cash_equal_505(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_504', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_505'] = _node_wt_cash_equal_505


def _node_if_506(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) < 35.0:
        return rt.call_node('_node_asset_PSQ_501', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_505', prices)
rt.NODE_REGISTRY['_node_if_506'] = _node_if_506


def _node_wt_cash_equal_507(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_506', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_507'] = _node_wt_cash_equal_507


def _node_asset_PSQ_508(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_508'] = _node_asset_PSQ_508


def _node_asset_SQQQ_509(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_509'] = _node_asset_SQQQ_509


def _node_if_510(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEF'], 10) > rt.relative_strength_index(prices['PSQ'], 20):
        return rt.call_node('_node_asset_PSQ_508', prices)
    else:
        return rt.call_node('_node_asset_SQQQ_509', prices)
rt.NODE_REGISTRY['_node_if_510'] = _node_if_510


def _node_wt_cash_equal_511(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_510', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_511'] = _node_wt_cash_equal_511


def _node_if_512(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TQQQ']) > rt.moving_average_price(prices['TQQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_507', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_511', prices)
rt.NODE_REGISTRY['_node_if_512'] = _node_if_512


def _node_wt_cash_equal_513(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_512', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_513'] = _node_wt_cash_equal_513


def _node_if_514(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TLT'], 20) > rt.relative_strength_index(prices['PSQ'], 20):
        return rt.call_node('_node_wt_cash_equal_500', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_513', prices)
rt.NODE_REGISTRY['_node_if_514'] = _node_if_514


def _node_asset_QLD_515(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'QLD': 1.0}
rt.NODE_REGISTRY['_node_asset_QLD_515'] = _node_asset_QLD_515


def _node_asset_BTAL_516(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BTAL': 1.0}
rt.NODE_REGISTRY['_node_asset_BTAL_516'] = _node_asset_BTAL_516


def _node_if_517(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['BND'], 10) > rt.relative_strength_index(prices['QQQ'], 10):
        return rt.call_node('_node_asset_QLD_515', prices)
    else:
        return rt.call_node('_node_asset_BTAL_516', prices)
rt.NODE_REGISTRY['_node_if_517'] = _node_if_517


def _node_wt_cash_equal_518(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_517', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_518'] = _node_wt_cash_equal_518


def _node_asset_PSQ_519(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_519'] = _node_asset_PSQ_519


def _node_asset_TQQQ_520(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_520'] = _node_asset_TQQQ_520


def _node_asset_PSQ_521(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_521'] = _node_asset_PSQ_521


def _node_if_522(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['AGG'], 20) > rt.relative_strength_index(prices['SH'], 60):
        return rt.call_node('_node_asset_TQQQ_520', prices)
    else:
        return rt.call_node('_node_asset_PSQ_521', prices)
rt.NODE_REGISTRY['_node_if_522'] = _node_if_522


def _node_wt_cash_equal_523(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_522', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_523'] = _node_wt_cash_equal_523


def _node_if_524(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) < 35.0:
        return rt.call_node('_node_asset_PSQ_519', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_523', prices)
rt.NODE_REGISTRY['_node_if_524'] = _node_if_524


def _node_wt_cash_equal_525(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_524', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_525'] = _node_wt_cash_equal_525


def _node_asset_PSQ_526(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PSQ': 1.0}
rt.NODE_REGISTRY['_node_asset_PSQ_526'] = _node_asset_PSQ_526


def _node_asset_SQQQ_527(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_527'] = _node_asset_SQQQ_527


def _node_if_528(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEF'], 10) > rt.relative_strength_index(prices['PSQ'], 20):
        return rt.call_node('_node_asset_PSQ_526', prices)
    else:
        return rt.call_node('_node_asset_SQQQ_527', prices)
rt.NODE_REGISTRY['_node_if_528'] = _node_if_528


def _node_wt_cash_equal_529(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_528', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_529'] = _node_wt_cash_equal_529


def _node_if_530(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TQQQ']) > rt.moving_average_price(prices['TQQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_525', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_529', prices)
rt.NODE_REGISTRY['_node_if_530'] = _node_if_530


def _node_wt_cash_equal_531(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_530', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_531'] = _node_wt_cash_equal_531


def _node_if_532(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['QQQ'], 60) < -12.0:
        return rt.call_node('_node_wt_cash_equal_518', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_531', prices)
rt.NODE_REGISTRY['_node_if_532'] = _node_if_532


def _node_wt_cash_equal_533(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_532', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_533'] = _node_wt_cash_equal_533


def _node_wt_cash_equal_534(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_514', prices), rt.call_node('_node_wt_cash_equal_533', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_534'] = _node_wt_cash_equal_534


def _node_wt_cash_equal_535(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_534', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_535'] = _node_wt_cash_equal_535


def _node_if_536(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_498', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_535', prices)
rt.NODE_REGISTRY['_node_if_536'] = _node_if_536


def _node_wt_cash_equal_537(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_536', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_537'] = _node_wt_cash_equal_537


def _node_if_538(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_asset_SPXL_408', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_537', prices)
rt.NODE_REGISTRY['_node_if_538'] = _node_if_538


def _node_wt_cash_equal_539(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_538', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_539'] = _node_wt_cash_equal_539


def _node_if_540(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) < 30.0:
        return rt.call_node('_node_asset_TQQQ_407', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_539', prices)
rt.NODE_REGISTRY['_node_if_540'] = _node_if_540


def _node_wt_cash_equal_541(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_540', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_541'] = _node_wt_cash_equal_541


def _node_if_542(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLF'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_406', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_541', prices)
rt.NODE_REGISTRY['_node_if_542'] = _node_if_542


def _node_wt_cash_equal_543(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_542', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_543'] = _node_wt_cash_equal_543


def _node_if_544(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_398', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_543', prices)
rt.NODE_REGISTRY['_node_if_544'] = _node_if_544


def _node_wt_cash_equal_545(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_544', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_545'] = _node_wt_cash_equal_545


def _node_if_546(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_387', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_545', prices)
rt.NODE_REGISTRY['_node_if_546'] = _node_if_546


def _node_wt_cash_equal_547(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_546', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_547'] = _node_wt_cash_equal_547


def _node_if_548(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IOO'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_373', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_547', prices)
rt.NODE_REGISTRY['_node_if_548'] = _node_if_548


def _node_wt_cash_equal_549(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_548', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_549'] = _node_wt_cash_equal_549


def _node_if_550(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_356', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_549', prices)
rt.NODE_REGISTRY['_node_if_550'] = _node_if_550


def _node_wt_cash_equal_551(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_550', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_551'] = _node_wt_cash_equal_551


def _node_wt_cash_equal_552(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_551', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_552'] = _node_wt_cash_equal_552


def _node_if_553(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPXL'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_336', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_552', prices)
rt.NODE_REGISTRY['_node_if_553'] = _node_if_553


def _node_wt_cash_equal_554(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_553', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_554'] = _node_wt_cash_equal_554


def _node_if_555(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_335', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_554', prices)
rt.NODE_REGISTRY['_node_if_555'] = _node_if_555


def _node_wt_cash_equal_556(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_555', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_556'] = _node_wt_cash_equal_556


def _node_asset_TECL_557(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_557'] = _node_asset_TECL_557


def _node_asset_UPRO_558(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UPRO': 1.0}
rt.NODE_REGISTRY['_node_asset_UPRO_558'] = _node_asset_UPRO_558


def _node_asset_SQQQ_559(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_559'] = _node_asset_SQQQ_559


def _node_asset_TLT_560(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TLT': 1.0}
rt.NODE_REGISTRY['_node_asset_TLT_560'] = _node_asset_TLT_560


def _node_filter_561(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_559', prices)), (rt.relative_strength_index(prices['TLT'], 10), rt.call_node('_node_asset_TLT_560', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_561'] = _node_filter_561


def _node_wt_cash_equal_562(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_561', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_562'] = _node_wt_cash_equal_562


def _node_asset_SQQQ_563(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_563'] = _node_asset_SQQQ_563


def _node_asset_TQQQ_564(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_564'] = _node_asset_TQQQ_564


def _node_wt_cash_equal_565(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_TQQQ_564', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_565'] = _node_wt_cash_equal_565


def _node_if_566(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SQQQ'], 10) < 31.0:
        return rt.call_node('_node_asset_SQQQ_563', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_565', prices)
rt.NODE_REGISTRY['_node_if_566'] = _node_if_566


def _node_wt_cash_equal_567(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_566', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_567'] = _node_wt_cash_equal_567


def _node_if_568(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TQQQ']) < rt.moving_average_price(prices['TQQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_562', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_567', prices)
rt.NODE_REGISTRY['_node_if_568'] = _node_if_568


def _node_wt_cash_equal_569(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_568', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_569'] = _node_wt_cash_equal_569


def _node_if_570(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_asset_UPRO_558', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_569', prices)
rt.NODE_REGISTRY['_node_if_570'] = _node_if_570


def _node_wt_cash_equal_571(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_570', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_571'] = _node_wt_cash_equal_571


def _node_if_572(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) < 31.0:
        return rt.call_node('_node_asset_TECL_557', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_571', prices)
rt.NODE_REGISTRY['_node_if_572'] = _node_if_572


def _node_wt_cash_equal_573(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_572', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_573'] = _node_wt_cash_equal_573


def _node_if_574(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_556', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_573', prices)
rt.NODE_REGISTRY['_node_if_574'] = _node_if_574


def _node_wt_cash_equal_575(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_574', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_575'] = _node_wt_cash_equal_575


def _node_wt_cash_equal_576(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_575', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_576'] = _node_wt_cash_equal_576


def _node_if_577(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['GDXU'], 70) < rt.cumulative_return(prices['GDXU'], 75):
        return rt.call_node('_node_asset_GDXU_334', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_576', prices)
rt.NODE_REGISTRY['_node_if_577'] = _node_if_577


def _node_wt_cash_equal_578(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_577', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_578'] = _node_wt_cash_equal_578


def _node_asset_GDXD_579(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GDXD': 1.0}
rt.NODE_REGISTRY['_node_asset_GDXD_579'] = _node_asset_GDXD_579


def _node_asset_V_580(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'V': 1.0}
rt.NODE_REGISTRY['_node_asset_V_580'] = _node_asset_V_580


def _node_asset_SOFI_581(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOFI': 1.0}
rt.NODE_REGISTRY['_node_asset_SOFI_581'] = _node_asset_SOFI_581


def _node_asset_MA_582(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'MA': 1.0}
rt.NODE_REGISTRY['_node_asset_MA_582'] = _node_asset_MA_582


def _node_asset_BX_583(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BX': 1.0}
rt.NODE_REGISTRY['_node_asset_BX_583'] = _node_asset_BX_583


def _node_asset_SCHW_584(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SCHW': 1.0}
rt.NODE_REGISTRY['_node_asset_SCHW_584'] = _node_asset_SCHW_584


def _node_asset_KKR_585(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'KKR': 1.0}
rt.NODE_REGISTRY['_node_asset_KKR_585'] = _node_asset_KKR_585


def _node_asset_BN_586(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BN': 1.0}
rt.NODE_REGISTRY['_node_asset_BN_586'] = _node_asset_BN_586


def _node_asset_WELL_587(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'WELL': 1.0}
rt.NODE_REGISTRY['_node_asset_WELL_587'] = _node_asset_WELL_587


def _node_asset_VTR_588(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VTR': 1.0}
rt.NODE_REGISTRY['_node_asset_VTR_588'] = _node_asset_VTR_588


def _node_asset_BAM_589(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BAM': 1.0}
rt.NODE_REGISTRY['_node_asset_BAM_589'] = _node_asset_BAM_589


def _node_asset_HOOD_590(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'HOOD': 1.0}
rt.NODE_REGISTRY['_node_asset_HOOD_590'] = _node_asset_HOOD_590


def _node_asset_IBKR_591(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'IBKR': 1.0}
rt.NODE_REGISTRY['_node_asset_IBKR_591'] = _node_asset_IBKR_591


def _node_asset_FAS_592(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FAS': 1.0}
rt.NODE_REGISTRY['_node_asset_FAS_592'] = _node_asset_FAS_592


def _node_asset_AAPX_593(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AAPX': 1.0}
rt.NODE_REGISTRY['_node_asset_AAPX_593'] = _node_asset_AAPX_593


def _node_asset_NVDL_594(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'NVDL': 1.0}
rt.NODE_REGISTRY['_node_asset_NVDL_594'] = _node_asset_NVDL_594


def _node_asset_BITX_595(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BITX': 1.0}
rt.NODE_REGISTRY['_node_asset_BITX_595'] = _node_asset_BITX_595


def _node_asset_TSLR_596(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TSLR': 1.0}
rt.NODE_REGISTRY['_node_asset_TSLR_596'] = _node_asset_TSLR_596


def _node_asset_FBL_597(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FBL': 1.0}
rt.NODE_REGISTRY['_node_asset_FBL_597'] = _node_asset_FBL_597


def _node_asset_GGLL_598(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GGLL': 1.0}
rt.NODE_REGISTRY['_node_asset_GGLL_598'] = _node_asset_GGLL_598


def _node_asset_AMZZ_599(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AMZZ': 1.0}
rt.NODE_REGISTRY['_node_asset_AMZZ_599'] = _node_asset_AMZZ_599


def _node_asset_RGTI_600(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'RGTI': 1.0}
rt.NODE_REGISTRY['_node_asset_RGTI_600'] = _node_asset_RGTI_600


def _node_asset_PLTR_601(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PLTR': 1.0}
rt.NODE_REGISTRY['_node_asset_PLTR_601'] = _node_asset_PLTR_601


def _node_asset_BABA_602(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BABA': 1.0}
rt.NODE_REGISTRY['_node_asset_BABA_602'] = _node_asset_BABA_602


def _node_asset_CONL_603(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'CONL': 1.0}
rt.NODE_REGISTRY['_node_asset_CONL_603'] = _node_asset_CONL_603


def _node_filter_604(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.moving_average_return(prices['AAPX'], 15), rt.call_node('_node_asset_AAPX_593', prices)), (rt.moving_average_return(prices['NVDL'], 15), rt.call_node('_node_asset_NVDL_594', prices)), (rt.moving_average_return(prices['BITX'], 15), rt.call_node('_node_asset_BITX_595', prices)), (rt.moving_average_return(prices['TSLR'], 15), rt.call_node('_node_asset_TSLR_596', prices)), (rt.moving_average_return(prices['FBL'], 15), rt.call_node('_node_asset_FBL_597', prices)), (rt.moving_average_return(prices['GGLL'], 15), rt.call_node('_node_asset_GGLL_598', prices)), (rt.moving_average_return(prices['AMZZ'], 15), rt.call_node('_node_asset_AMZZ_599', prices)), (rt.moving_average_return(prices['RGTI'], 15), rt.call_node('_node_asset_RGTI_600', prices)), (rt.moving_average_return(prices['PLTR'], 15), rt.call_node('_node_asset_PLTR_601', prices)), (rt.moving_average_return(prices['BABA'], 15), rt.call_node('_node_asset_BABA_602', prices)), (rt.moving_average_return(prices['CONL'], 15), rt.call_node('_node_asset_CONL_603', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_604'] = _node_filter_604


def _node_wt_cash_equal_605(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_604', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_605'] = _node_wt_cash_equal_605


def _node_if_606(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['FAS'], 10) > rt.moving_average_return(prices['QQQ'], 20):
        return rt.call_node('_node_asset_FAS_592', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_605', prices)
rt.NODE_REGISTRY['_node_if_606'] = _node_if_606


def _node_wt_cash_equal_607(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_606', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_607'] = _node_wt_cash_equal_607


def _node_filter_608(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.moving_average_return(prices['V'], 20), rt.call_node('_node_asset_V_580', prices)), (rt.moving_average_return(prices['SOFI'], 20), rt.call_node('_node_asset_SOFI_581', prices)), (rt.moving_average_return(prices['MA'], 20), rt.call_node('_node_asset_MA_582', prices)), (rt.moving_average_return(prices['BX'], 20), rt.call_node('_node_asset_BX_583', prices)), (rt.moving_average_return(prices['SCHW'], 20), rt.call_node('_node_asset_SCHW_584', prices)), (rt.moving_average_return(prices['KKR'], 20), rt.call_node('_node_asset_KKR_585', prices)), (rt.moving_average_return(prices['BN'], 20), rt.call_node('_node_asset_BN_586', prices)), (rt.moving_average_return(prices['WELL'], 20), rt.call_node('_node_asset_WELL_587', prices)), (rt.moving_average_return(prices['VTR'], 20), rt.call_node('_node_asset_VTR_588', prices)), (rt.moving_average_return(prices['BAM'], 20), rt.call_node('_node_asset_BAM_589', prices)), (rt.moving_average_return(prices['HOOD'], 20), rt.call_node('_node_asset_HOOD_590', prices)), (rt.moving_average_return(prices['IBKR'], 20), rt.call_node('_node_asset_IBKR_591', prices)), (rt.moving_average_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_607', prices), prices), 20), rt.call_node('_node_wt_cash_equal_607', prices))], 'top', int('3'))
rt.NODE_REGISTRY['_node_filter_608'] = _node_filter_608


def _node_wt_cash_equal_609(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_608', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_609'] = _node_wt_cash_equal_609


def _node_asset_V_610(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'V': 1.0}
rt.NODE_REGISTRY['_node_asset_V_610'] = _node_asset_V_610


def _node_asset_SOFI_611(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOFI': 1.0}
rt.NODE_REGISTRY['_node_asset_SOFI_611'] = _node_asset_SOFI_611


def _node_asset_MA_612(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'MA': 1.0}
rt.NODE_REGISTRY['_node_asset_MA_612'] = _node_asset_MA_612


def _node_asset_BX_613(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BX': 1.0}
rt.NODE_REGISTRY['_node_asset_BX_613'] = _node_asset_BX_613


def _node_asset_SCHW_614(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SCHW': 1.0}
rt.NODE_REGISTRY['_node_asset_SCHW_614'] = _node_asset_SCHW_614


def _node_asset_KKR_615(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'KKR': 1.0}
rt.NODE_REGISTRY['_node_asset_KKR_615'] = _node_asset_KKR_615


def _node_asset_BN_616(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BN': 1.0}
rt.NODE_REGISTRY['_node_asset_BN_616'] = _node_asset_BN_616


def _node_asset_WELL_617(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'WELL': 1.0}
rt.NODE_REGISTRY['_node_asset_WELL_617'] = _node_asset_WELL_617


def _node_asset_VTR_618(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VTR': 1.0}
rt.NODE_REGISTRY['_node_asset_VTR_618'] = _node_asset_VTR_618


def _node_asset_BAM_619(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BAM': 1.0}
rt.NODE_REGISTRY['_node_asset_BAM_619'] = _node_asset_BAM_619


def _node_asset_HOOD_620(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'HOOD': 1.0}
rt.NODE_REGISTRY['_node_asset_HOOD_620'] = _node_asset_HOOD_620


def _node_asset_IBKR_621(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'IBKR': 1.0}
rt.NODE_REGISTRY['_node_asset_IBKR_621'] = _node_asset_IBKR_621


def _node_filter_622(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['V'], 10), rt.call_node('_node_asset_V_610', prices)), (rt.relative_strength_index(prices['SOFI'], 10), rt.call_node('_node_asset_SOFI_611', prices)), (rt.relative_strength_index(prices['MA'], 10), rt.call_node('_node_asset_MA_612', prices)), (rt.relative_strength_index(prices['BX'], 10), rt.call_node('_node_asset_BX_613', prices)), (rt.relative_strength_index(prices['SCHW'], 10), rt.call_node('_node_asset_SCHW_614', prices)), (rt.relative_strength_index(prices['KKR'], 10), rt.call_node('_node_asset_KKR_615', prices)), (rt.relative_strength_index(prices['BN'], 10), rt.call_node('_node_asset_BN_616', prices)), (rt.relative_strength_index(prices['WELL'], 10), rt.call_node('_node_asset_WELL_617', prices)), (rt.relative_strength_index(prices['VTR'], 10), rt.call_node('_node_asset_VTR_618', prices)), (rt.relative_strength_index(prices['BAM'], 10), rt.call_node('_node_asset_BAM_619', prices)), (rt.relative_strength_index(prices['HOOD'], 10), rt.call_node('_node_asset_HOOD_620', prices)), (rt.relative_strength_index(prices['IBKR'], 10), rt.call_node('_node_asset_IBKR_621', prices))], 'bottom', int('3'))
rt.NODE_REGISTRY['_node_filter_622'] = _node_filter_622


def _node_wt_cash_equal_623(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_622', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_623'] = _node_wt_cash_equal_623


def _node_if_624(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['FAS'], 50) > rt.moving_average_return(prices['FAS'], 200):
        return rt.call_node('_node_wt_cash_equal_609', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_623', prices)
rt.NODE_REGISTRY['_node_if_624'] = _node_if_624


def _node_wt_cash_equal_625(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_624', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_625'] = _node_wt_cash_equal_625


def _node_asset_TMF_626(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TMF': 1.0}
rt.NODE_REGISTRY['_node_asset_TMF_626'] = _node_asset_TMF_626


def _node_asset_FAZ_627(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FAZ': 1.0}
rt.NODE_REGISTRY['_node_asset_FAZ_627'] = _node_asset_FAZ_627


def _node_asset_AAPX_628(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AAPX': 1.0}
rt.NODE_REGISTRY['_node_asset_AAPX_628'] = _node_asset_AAPX_628


def _node_asset_NVDL_629(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'NVDL': 1.0}
rt.NODE_REGISTRY['_node_asset_NVDL_629'] = _node_asset_NVDL_629


def _node_asset_BITX_630(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BITX': 1.0}
rt.NODE_REGISTRY['_node_asset_BITX_630'] = _node_asset_BITX_630


def _node_asset_TSLR_631(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TSLR': 1.0}
rt.NODE_REGISTRY['_node_asset_TSLR_631'] = _node_asset_TSLR_631


def _node_asset_FBL_632(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FBL': 1.0}
rt.NODE_REGISTRY['_node_asset_FBL_632'] = _node_asset_FBL_632


def _node_asset_GGLL_633(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GGLL': 1.0}
rt.NODE_REGISTRY['_node_asset_GGLL_633'] = _node_asset_GGLL_633


def _node_asset_AMZZ_634(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AMZZ': 1.0}
rt.NODE_REGISTRY['_node_asset_AMZZ_634'] = _node_asset_AMZZ_634


def _node_asset_RGTI_635(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'RGTI': 1.0}
rt.NODE_REGISTRY['_node_asset_RGTI_635'] = _node_asset_RGTI_635


def _node_asset_PLTR_636(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'PLTR': 1.0}
rt.NODE_REGISTRY['_node_asset_PLTR_636'] = _node_asset_PLTR_636


def _node_asset_BABA_637(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BABA': 1.0}
rt.NODE_REGISTRY['_node_asset_BABA_637'] = _node_asset_BABA_637


def _node_asset_CONL_638(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'CONL': 1.0}
rt.NODE_REGISTRY['_node_asset_CONL_638'] = _node_asset_CONL_638


def _node_filter_639(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.moving_average_return(prices['AAPX'], 15), rt.call_node('_node_asset_AAPX_628', prices)), (rt.moving_average_return(prices['NVDL'], 15), rt.call_node('_node_asset_NVDL_629', prices)), (rt.moving_average_return(prices['BITX'], 15), rt.call_node('_node_asset_BITX_630', prices)), (rt.moving_average_return(prices['TSLR'], 15), rt.call_node('_node_asset_TSLR_631', prices)), (rt.moving_average_return(prices['FBL'], 15), rt.call_node('_node_asset_FBL_632', prices)), (rt.moving_average_return(prices['GGLL'], 15), rt.call_node('_node_asset_GGLL_633', prices)), (rt.moving_average_return(prices['AMZZ'], 15), rt.call_node('_node_asset_AMZZ_634', prices)), (rt.moving_average_return(prices['RGTI'], 15), rt.call_node('_node_asset_RGTI_635', prices)), (rt.moving_average_return(prices['PLTR'], 15), rt.call_node('_node_asset_PLTR_636', prices)), (rt.moving_average_return(prices['BABA'], 15), rt.call_node('_node_asset_BABA_637', prices)), (rt.moving_average_return(prices['CONL'], 15), rt.call_node('_node_asset_CONL_638', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_639'] = _node_filter_639


def _node_wt_cash_equal_640(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_639', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_640'] = _node_wt_cash_equal_640


def _node_filter_641(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.moving_average_return(prices['TMF'], 15), rt.call_node('_node_asset_TMF_626', prices)), (rt.moving_average_return(prices['FAZ'], 15), rt.call_node('_node_asset_FAZ_627', prices)), (rt.moving_average_return(rt.synthetic_price_series(rt.call_node('_node_wt_cash_equal_640', prices), prices), 15), rt.call_node('_node_wt_cash_equal_640', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_641'] = _node_filter_641


def _node_wt_cash_equal_642(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_641', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_642'] = _node_wt_cash_equal_642


def _node_asset_AGQ_643(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'AGQ': 1.0}
rt.NODE_REGISTRY['_node_asset_AGQ_643'] = _node_asset_AGQ_643


def _node_asset_FAS_644(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FAS': 1.0}
rt.NODE_REGISTRY['_node_asset_FAS_644'] = _node_asset_FAS_644


def _node_filter_645(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['AGQ'], 10), rt.call_node('_node_asset_AGQ_643', prices)), (rt.relative_strength_index(prices['FAS'], 10), rt.call_node('_node_asset_FAS_644', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_645'] = _node_filter_645


def _node_wt_cash_equal_646(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_645', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_646'] = _node_wt_cash_equal_646


def _node_if_647(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['FAS'], 10) > 31.0:
        return rt.call_node('_node_wt_cash_equal_642', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_646', prices)
rt.NODE_REGISTRY['_node_if_647'] = _node_if_647


def _node_wt_cash_equal_648(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_647', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_648'] = _node_wt_cash_equal_648


def _node_asset_FAS_649(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'FAS': 1.0}
rt.NODE_REGISTRY['_node_asset_FAS_649'] = _node_asset_FAS_649


def _node_if_650(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['FAS']) < rt.moving_average_price(prices['FAS'], 100):
        return rt.call_node('_node_wt_cash_equal_648', prices)
    else:
        return rt.call_node('_node_asset_FAS_649', prices)
rt.NODE_REGISTRY['_node_if_650'] = _node_if_650


def _node_wt_cash_equal_651(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_650', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_651'] = _node_wt_cash_equal_651


def _node_if_652(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_625', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_651', prices)
rt.NODE_REGISTRY['_node_if_652'] = _node_if_652


def _node_wt_cash_equal_653(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_652', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_653'] = _node_wt_cash_equal_653


def _node_if_654(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['TLT'], 95) < rt.cumulative_return(prices['QQQ'], 35):
        return rt.call_node('_node_asset_GDXD_579', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_653', prices)
rt.NODE_REGISTRY['_node_if_654'] = _node_if_654


def _node_wt_cash_equal_655(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_654', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_655'] = _node_wt_cash_equal_655


def _node_if_656(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['QQQ'], 90) > rt.cumulative_return(prices['QQQ'], 70):
        return rt.call_node('_node_wt_cash_equal_578', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_655', prices)
rt.NODE_REGISTRY['_node_if_656'] = _node_if_656


def _node_wt_cash_equal_657(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_656', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_657'] = _node_wt_cash_equal_657


def _node_if_658(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['GDXU'], 10) < 30.0:
        return rt.call_node('_node_asset_GDXU_333', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_657', prices)
rt.NODE_REGISTRY['_node_if_658'] = _node_if_658


def _node_wt_cash_equal_659(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_658', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_659'] = _node_wt_cash_equal_659


def _node_if_660(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['GDXU'], 10) > 79.0:
        return rt.call_node('_node_asset_GDXD_332', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_659', prices)
rt.NODE_REGISTRY['_node_if_660'] = _node_if_660


def _node_wt_cash_equal_661(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_660', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_661'] = _node_wt_cash_equal_661


def _node_asset_SOXL_662(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_662'] = _node_asset_SOXL_662


def _node_asset_SOXL_663(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_663'] = _node_asset_SOXL_663


def _node_asset_SOXL_664(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_664'] = _node_asset_SOXL_664


def _node_asset_SOXL_665(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_665'] = _node_asset_SOXL_665


def _node_asset_SOXL_666(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_666'] = _node_asset_SOXL_666


def _node_asset_UVXY_667(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_667'] = _node_asset_UVXY_667


def _node_asset_UVXY_668(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_668'] = _node_asset_UVXY_668


def _node_wt_cash_equal_669(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_UVXY_668', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_669'] = _node_wt_cash_equal_669


def _node_asset_UVXY_670(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_670'] = _node_asset_UVXY_670


def _node_asset_UVXY_671(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_671'] = _node_asset_UVXY_671


def _node_asset_UVXY_672(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_672'] = _node_asset_UVXY_672


def _node_asset_UVXY_673(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_673'] = _node_asset_UVXY_673


def _node_asset_BIL_674(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_674'] = _node_asset_BIL_674


def _node_asset_BIL_675(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_675'] = _node_asset_BIL_675


def _node_asset_BIL_676(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_676'] = _node_asset_BIL_676


def _node_asset_BIL_677(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_677'] = _node_asset_BIL_677


def _node_asset_BIL_678(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_678'] = _node_asset_BIL_678


def _node_asset_SOXL_679(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_679'] = _node_asset_SOXL_679


def _node_asset_UVXY_680(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_680'] = _node_asset_UVXY_680


def _node_asset_TMF_681(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TMF': 1.0}
rt.NODE_REGISTRY['_node_asset_TMF_681'] = _node_asset_TMF_681


def _node_asset_SOXL_682(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_682'] = _node_asset_SOXL_682


def _node_wt_cash_equal_683(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_682', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_683'] = _node_wt_cash_equal_683


def _node_asset_SOXL_684(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_684'] = _node_asset_SOXL_684


def _node_wt_cash_equal_685(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_684', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_685'] = _node_wt_cash_equal_685


def _node_asset_SOXL_686(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_686'] = _node_asset_SOXL_686


def _node_wt_cash_equal_687(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_686', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_687'] = _node_wt_cash_equal_687


def _node_asset_SOXL_688(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_688'] = _node_asset_SOXL_688


def _node_wt_cash_equal_689(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_688', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_689'] = _node_wt_cash_equal_689


def _node_asset_UPRO_690(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UPRO': 1.0}
rt.NODE_REGISTRY['_node_asset_UPRO_690'] = _node_asset_UPRO_690


def _node_asset_TQQQ_691(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_691'] = _node_asset_TQQQ_691


def _node_wt_cash_specified_692(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('80') / float(100)), rt.call_node('_node_asset_UPRO_690', prices)), ((float(20) / float(100)), rt.call_node('_node_asset_TQQQ_691', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_692'] = _node_wt_cash_specified_692


def _node_if_693(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_689', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_692', prices)
rt.NODE_REGISTRY['_node_if_693'] = _node_if_693


def _node_wt_cash_equal_694(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_693', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_694'] = _node_wt_cash_equal_694

# region imports
from AlgorithmImports import *
# endregion
from typing import Dict, Sequence

import strategy_runtime as rt


def _node_if_695(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_687', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_694', prices)
rt.NODE_REGISTRY['_node_if_695'] = _node_if_695


def _node_wt_cash_equal_696(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_695', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_696'] = _node_wt_cash_equal_696


def _node_if_697(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 95.0:
        return rt.call_node('_node_wt_cash_equal_685', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_696', prices)
rt.NODE_REGISTRY['_node_if_697'] = _node_if_697


def _node_wt_cash_equal_698(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_697', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_698'] = _node_wt_cash_equal_698


def _node_if_699(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 60.0:
        return rt.call_node('_node_wt_cash_equal_683', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_698', prices)
rt.NODE_REGISTRY['_node_if_699'] = _node_if_699


def _node_wt_cash_equal_700(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_699', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_700'] = _node_wt_cash_equal_700


def _node_if_701(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -16.0:
        return rt.call_node('_node_asset_TMF_681', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_700', prices)
rt.NODE_REGISTRY['_node_if_701'] = _node_if_701


def _node_wt_cash_equal_702(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_701', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_702'] = _node_wt_cash_equal_702


def _node_if_703(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -20.0:
        return rt.call_node('_node_asset_UVXY_680', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_702', prices)
rt.NODE_REGISTRY['_node_if_703'] = _node_if_703


def _node_wt_cash_equal_704(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_703', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_704'] = _node_wt_cash_equal_704


def _node_if_705(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -25.0:
        return rt.call_node('_node_asset_SOXL_679', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_704', prices)
rt.NODE_REGISTRY['_node_if_705'] = _node_if_705


def _node_wt_cash_equal_706(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_705', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_706'] = _node_wt_cash_equal_706


def _node_if_707(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 200) > 55.0:
        return rt.call_node('_node_asset_BIL_678', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_706', prices)
rt.NODE_REGISTRY['_node_if_707'] = _node_if_707


def _node_wt_cash_equal_708(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_707', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_708'] = _node_wt_cash_equal_708


def _node_wt_cash_equal_709(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_708', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_709'] = _node_wt_cash_equal_709


def _node_if_710(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 60.0:
        return rt.call_node('_node_asset_BIL_677', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_709', prices)
rt.NODE_REGISTRY['_node_if_710'] = _node_if_710


def _node_wt_cash_equal_711(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_710', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_711'] = _node_wt_cash_equal_711


def _node_if_712(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 14) > 95.0:
        return rt.call_node('_node_asset_BIL_676', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_711', prices)
rt.NODE_REGISTRY['_node_if_712'] = _node_if_712


def _node_wt_cash_equal_713(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_712', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_713'] = _node_wt_cash_equal_713


def _node_if_714(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 60) > 65.0:
        return rt.call_node('_node_asset_BIL_675', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_713', prices)
rt.NODE_REGISTRY['_node_if_714'] = _node_if_714


def _node_wt_cash_equal_715(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_714', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_715'] = _node_wt_cash_equal_715


def _node_if_716(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 65.0:
        return rt.call_node('_node_asset_BIL_674', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_715', prices)
rt.NODE_REGISTRY['_node_if_716'] = _node_if_716


def _node_wt_cash_equal_717(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_716', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_717'] = _node_wt_cash_equal_717


def _node_if_718(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 6) > 85.0:
        return rt.call_node('_node_asset_UVXY_673', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_717', prices)
rt.NODE_REGISTRY['_node_if_718'] = _node_if_718


def _node_wt_cash_equal_719(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_718', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_719'] = _node_wt_cash_equal_719


def _node_if_720(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 5) > 90.0:
        return rt.call_node('_node_asset_UVXY_672', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_719', prices)
rt.NODE_REGISTRY['_node_if_720'] = _node_if_720


def _node_wt_cash_equal_721(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_720', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_721'] = _node_wt_cash_equal_721


def _node_if_722(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 5) > 90.0:
        return rt.call_node('_node_asset_UVXY_671', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_721', prices)
rt.NODE_REGISTRY['_node_if_722'] = _node_if_722


def _node_wt_cash_equal_723(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_722', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_723'] = _node_wt_cash_equal_723


def _node_if_724(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_670', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_723', prices)
rt.NODE_REGISTRY['_node_if_724'] = _node_if_724


def _node_wt_cash_equal_725(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_724', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_725'] = _node_wt_cash_equal_725


def _node_if_726(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_669', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_725', prices)
rt.NODE_REGISTRY['_node_if_726'] = _node_if_726


def _node_wt_cash_equal_727(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_726', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_727'] = _node_wt_cash_equal_727


def _node_if_728(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 75.0:
        return rt.call_node('_node_asset_UVXY_667', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_727', prices)
rt.NODE_REGISTRY['_node_if_728'] = _node_if_728


def _node_wt_cash_specified_729(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float(100) / float(100)), rt.call_node('_node_if_728', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_729'] = _node_wt_cash_specified_729


def _node_if_730(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 84.0:
        return rt.call_node('_node_asset_SOXL_666', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_729', prices)
rt.NODE_REGISTRY['_node_if_730'] = _node_if_730


def _node_wt_cash_equal_731(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_730', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_731'] = _node_wt_cash_equal_731


def _node_asset_SOXL_732(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_732'] = _node_asset_SOXL_732


def _node_asset_UVXY_733(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_733'] = _node_asset_UVXY_733


def _node_asset_BIL_734(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_734'] = _node_asset_BIL_734


def _node_asset_BIL_735(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_735'] = _node_asset_BIL_735


def _node_asset_BIL_736(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_736'] = _node_asset_BIL_736


def _node_asset_BIL_737(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_737'] = _node_asset_BIL_737


def _node_asset_BIL_738(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_738'] = _node_asset_BIL_738


def _node_asset_UVXY_739(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_739'] = _node_asset_UVXY_739


def _node_asset_SOXL_740(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_740'] = _node_asset_SOXL_740


def _node_wt_cash_equal_741(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_740', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_741'] = _node_wt_cash_equal_741


def _node_asset_BIL_742(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_742'] = _node_asset_BIL_742


def _node_asset_SOXL_743(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_743'] = _node_asset_SOXL_743


def _node_if_744(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) < 84.0:
        return rt.call_node('_node_asset_BIL_742', prices)
    else:
        return rt.call_node('_node_asset_SOXL_743', prices)
rt.NODE_REGISTRY['_node_if_744'] = _node_if_744


def _node_wt_cash_equal_745(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_744', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_745'] = _node_wt_cash_equal_745


def _node_asset_SOXL_746(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_746'] = _node_asset_SOXL_746


def _node_wt_cash_equal_747(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_746', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_747'] = _node_wt_cash_equal_747


def _node_asset_SOXL_748(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_748'] = _node_asset_SOXL_748


def _node_wt_cash_equal_749(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_748', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_749'] = _node_wt_cash_equal_749


def _node_asset_SQQQ_750(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_750'] = _node_asset_SQQQ_750


def _node_wt_cash_equal_751(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SQQQ_750', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_751'] = _node_wt_cash_equal_751


def _node_asset_SOXL_752(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_752'] = _node_asset_SOXL_752


def _node_wt_cash_equal_753(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_752', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_753'] = _node_wt_cash_equal_753


def _node_if_754(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_751', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_753', prices)
rt.NODE_REGISTRY['_node_if_754'] = _node_if_754


def _node_wt_cash_equal_755(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_754', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_755'] = _node_wt_cash_equal_755


def _node_asset_SOXL_756(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_756'] = _node_asset_SOXL_756


def _node_wt_cash_equal_757(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_756', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_757'] = _node_wt_cash_equal_757


def _node_asset_SOXL_758(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_758'] = _node_asset_SOXL_758


def _node_wt_cash_equal_759(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_758', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_759'] = _node_wt_cash_equal_759


def _node_asset_SOXL_760(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_760'] = _node_asset_SOXL_760


def _node_wt_cash_equal_761(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_SOXL_760', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_761'] = _node_wt_cash_equal_761


def _node_asset_GLD_762(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'GLD': 1.0}
rt.NODE_REGISTRY['_node_asset_GLD_762'] = _node_asset_GLD_762


def _node_if_763(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > rt.relative_strength_index(prices['TLT'], 10):
        return rt.call_node('_node_wt_cash_equal_761', prices)
    else:
        return rt.call_node('_node_asset_GLD_762', prices)
rt.NODE_REGISTRY['_node_if_763'] = _node_if_763


def _node_wt_cash_equal_764(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_763', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_764'] = _node_wt_cash_equal_764


def _node_asset_SQQQ_765(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_765'] = _node_asset_SQQQ_765


def _node_asset_TLT_766(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TLT': 1.0}
rt.NODE_REGISTRY['_node_asset_TLT_766'] = _node_asset_TLT_766


def _node_filter_767(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_765', prices)), (rt.relative_strength_index(prices['TLT'], 10), rt.call_node('_node_asset_TLT_766', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_767'] = _node_filter_767


def _node_wt_cash_equal_768(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_767', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_768'] = _node_wt_cash_equal_768


def _node_asset_TMF_769(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TMF': 1.0}
rt.NODE_REGISTRY['_node_asset_TMF_769'] = _node_asset_TMF_769


def _node_asset_TQQQ_770(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_TQQQ_770'] = _node_asset_TQQQ_770


def _node_wt_cash_equal_771(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_TQQQ_770', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_771'] = _node_wt_cash_equal_771


def _node_if_772(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['TLT']) > rt.moving_average_price(prices['TLT'], 200):
        return rt.call_node('_node_asset_TMF_769', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_771', prices)
rt.NODE_REGISTRY['_node_if_772'] = _node_if_772


def _node_wt_cash_equal_773(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_772', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_773'] = _node_wt_cash_equal_773


def _node_if_774(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) > rt.relative_strength_index(prices['TLT'], 10):
        return rt.call_node('_node_wt_cash_equal_768', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_773', prices)
rt.NODE_REGISTRY['_node_if_774'] = _node_if_774


def _node_wt_cash_equal_775(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_774', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_775'] = _node_wt_cash_equal_775


def _node_if_776(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['PSQ'], 10) > 65.0:
        return rt.call_node('_node_wt_cash_equal_764', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_775', prices)
rt.NODE_REGISTRY['_node_if_776'] = _node_if_776


def _node_wt_cash_equal_777(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_776', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_777'] = _node_wt_cash_equal_777


def _node_wt_cash_equal_778(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_777', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_778'] = _node_wt_cash_equal_778


def _node_if_779(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 30):
        return rt.call_node('_node_wt_cash_equal_759', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_778', prices)
rt.NODE_REGISTRY['_node_if_779'] = _node_if_779


def _node_wt_cash_equal_780(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_779', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_780'] = _node_wt_cash_equal_780


def _node_if_781(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_757', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_780', prices)
rt.NODE_REGISTRY['_node_if_781'] = _node_if_781


def _node_wt_cash_equal_782(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_781', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_782'] = _node_wt_cash_equal_782


def _node_if_783(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['QQQ']) > rt.moving_average_price(prices['QQQ'], 20):
        return rt.call_node('_node_wt_cash_equal_755', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_782', prices)
rt.NODE_REGISTRY['_node_if_783'] = _node_if_783


def _node_wt_cash_equal_784(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_783', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_784'] = _node_wt_cash_equal_784


def _node_if_785(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_749', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_784', prices)
rt.NODE_REGISTRY['_node_if_785'] = _node_if_785


def _node_wt_cash_equal_786(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_785', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_786'] = _node_wt_cash_equal_786


def _node_if_787(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 30.0:
        return rt.call_node('_node_wt_cash_equal_747', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_786', prices)
rt.NODE_REGISTRY['_node_if_787'] = _node_if_787


def _node_wt_cash_equal_788(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_787', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_788'] = _node_wt_cash_equal_788


def _node_if_789(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 74.0:
        return rt.call_node('_node_wt_cash_equal_745', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_788', prices)
rt.NODE_REGISTRY['_node_if_789'] = _node_if_789


def _node_wt_cash_equal_790(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_789', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_790'] = _node_wt_cash_equal_790


def _node_if_791(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) < 20.0:
        return rt.call_node('_node_wt_cash_equal_741', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_790', prices)
rt.NODE_REGISTRY['_node_if_791'] = _node_if_791


def _node_wt_cash_equal_792(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_791', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_792'] = _node_wt_cash_equal_792


def _node_if_793(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -24.0:
        return rt.call_node('_node_asset_UVXY_739', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_792', prices)
rt.NODE_REGISTRY['_node_if_793'] = _node_if_793


def _node_wt_cash_equal_794(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_793', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_794'] = _node_wt_cash_equal_794


def _node_if_795(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 60) > 50.0:
        return rt.call_node('_node_asset_BIL_738', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_794', prices)
rt.NODE_REGISTRY['_node_if_795'] = _node_if_795


def _node_wt_cash_equal_796(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_795', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_796'] = _node_wt_cash_equal_796


def _node_if_797(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 60) > 55.0:
        return rt.call_node('_node_asset_BIL_737', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_796', prices)
rt.NODE_REGISTRY['_node_if_797'] = _node_if_797


def _node_wt_cash_equal_798(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_797', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_798'] = _node_wt_cash_equal_798


def _node_if_799(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 6) > 75.0:
        return rt.call_node('_node_asset_BIL_736', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_798', prices)
rt.NODE_REGISTRY['_node_if_799'] = _node_if_799


def _node_wt_cash_equal_800(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_799', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_800'] = _node_wt_cash_equal_800


def _node_if_801(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQ'], 10) > 75.0:
        return rt.call_node('_node_asset_BIL_735', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_800', prices)
rt.NODE_REGISTRY['_node_if_801'] = _node_if_801


def _node_wt_cash_equal_802(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_801', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_802'] = _node_wt_cash_equal_802


def _node_if_803(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 70.0:
        return rt.call_node('_node_asset_BIL_734', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_802', prices)
rt.NODE_REGISTRY['_node_if_803'] = _node_if_803


def _node_wt_cash_equal_804(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_803', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_804'] = _node_wt_cash_equal_804


def _node_if_805(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 75.0:
        return rt.call_node('_node_asset_UVXY_733', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_804', prices)
rt.NODE_REGISTRY['_node_if_805'] = _node_if_805


def _node_wt_cash_equal_806(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_805', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_806'] = _node_wt_cash_equal_806


def _node_if_807(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 10) > 84.0:
        return rt.call_node('_node_asset_SOXL_732', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_806', prices)
rt.NODE_REGISTRY['_node_if_807'] = _node_if_807


def _node_wt_cash_equal_808(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_807', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_808'] = _node_wt_cash_equal_808


def _node_if_809(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_731', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_808', prices)
rt.NODE_REGISTRY['_node_if_809'] = _node_if_809


def _node_wt_cash_equal_810(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_809', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_810'] = _node_wt_cash_equal_810


def _node_if_811(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 5) < -57.0:
        return rt.call_node('_node_asset_SOXL_665', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_810', prices)
rt.NODE_REGISTRY['_node_if_811'] = _node_if_811


def _node_wt_cash_equal_812(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_811', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_812'] = _node_wt_cash_equal_812


def _node_if_813(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 2) < -37.0:
        return rt.call_node('_node_asset_SOXL_664', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_812', prices)
rt.NODE_REGISTRY['_node_if_813'] = _node_if_813


def _node_wt_cash_equal_814(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_813', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_814'] = _node_wt_cash_equal_814


def _node_if_815(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.cumulative_return(prices['SOXL'], 1) < -31.0:
        return rt.call_node('_node_asset_SOXL_663', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_814', prices)
rt.NODE_REGISTRY['_node_if_815'] = _node_if_815


def _node_wt_cash_equal_816(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_815', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_816'] = _node_wt_cash_equal_816


def _node_if_817(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.moving_average_return(prices['QQQ'], 10) < -2.4:
        return rt.call_node('_node_asset_SOXL_662', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_816', prices)
rt.NODE_REGISTRY['_node_if_817'] = _node_if_817


def _node_wt_cash_equal_818(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_817', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_818'] = _node_wt_cash_equal_818


def _node_wt_cash_equal_819(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_818', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_819'] = _node_wt_cash_equal_819


def _node_asset_UVXY_820(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_820'] = _node_asset_UVXY_820


def _node_asset_UVXY_821(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_821'] = _node_asset_UVXY_821


def _node_asset_UVXY_822(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_822'] = _node_asset_UVXY_822


def _node_asset_UVXY_823(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_823'] = _node_asset_UVXY_823


def _node_asset_UVXY_824(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_824'] = _node_asset_UVXY_824


def _node_asset_UVXY_825(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_825'] = _node_asset_UVXY_825


def _node_asset_UVXY_826(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_826'] = _node_asset_UVXY_826


def _node_asset_UVXY_827(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_827'] = _node_asset_UVXY_827


def _node_wt_cash_equal_828(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_asset_UVXY_827', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_828'] = _node_wt_cash_equal_828


def _node_asset_UVXY_829(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_829'] = _node_asset_UVXY_829


def _node_asset_UVXY_830(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_830'] = _node_asset_UVXY_830


def _node_asset_UVXY_831(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'UVXY': 1.0}
rt.NODE_REGISTRY['_node_asset_UVXY_831'] = _node_asset_UVXY_831


def _node_asset_VIXM_832(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'VIXM': 1.0}
rt.NODE_REGISTRY['_node_asset_VIXM_832'] = _node_asset_VIXM_832


def _node_asset_SPXL_833(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SPXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SPXL_833'] = _node_asset_SPXL_833


def _node_if_834(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 21) > 30.0:
        return rt.call_node('_node_asset_VIXM_832', prices)
    else:
        return rt.call_node('_node_asset_SPXL_833', prices)
rt.NODE_REGISTRY['_node_if_834'] = _node_if_834


def _node_wt_cash_equal_835(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_834', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_835'] = _node_wt_cash_equal_835


def _node_wt_cash_equal_836(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_835', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_836'] = _node_wt_cash_equal_836


def _node_asset_TECL_837(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_837'] = _node_asset_TECL_837


def _node_asset_SOXL_838(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_838'] = _node_asset_SOXL_838


def _node_asset_SPXL_839(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SPXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SPXL_839'] = _node_asset_SPXL_839


def _node_asset_TECL_840(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TECL': 1.0}
rt.NODE_REGISTRY['_node_asset_TECL_840'] = _node_asset_TECL_840


def _node_asset_SOXL_841(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SOXL': 1.0}
rt.NODE_REGISTRY['_node_asset_SOXL_841'] = _node_asset_SOXL_841


def _node_asset_SVIX_842(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SVIX': 1.0}
rt.NODE_REGISTRY['_node_asset_SVIX_842'] = _node_asset_SVIX_842


def _node_filter_843(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['TECL'], 10), rt.call_node('_node_asset_TECL_840', prices)), (rt.relative_strength_index(prices['SOXL'], 10), rt.call_node('_node_asset_SOXL_841', prices)), (rt.relative_strength_index(prices['SVIX'], 10), rt.call_node('_node_asset_SVIX_842', prices))], 'bottom', int('1'))
rt.NODE_REGISTRY['_node_filter_843'] = _node_filter_843


def _node_wt_cash_equal_844(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_843', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_844'] = _node_wt_cash_equal_844


def _node_asset_SQQQ_845(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'SQQQ': 1.0}
rt.NODE_REGISTRY['_node_asset_SQQQ_845'] = _node_asset_SQQQ_845


def _node_asset_TLT_846(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'TLT': 1.0}
rt.NODE_REGISTRY['_node_asset_TLT_846'] = _node_asset_TLT_846


def _node_filter_847(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.select_filter([(rt.relative_strength_index(prices['SQQQ'], 10), rt.call_node('_node_asset_SQQQ_845', prices)), (rt.relative_strength_index(prices['TLT'], 10), rt.call_node('_node_asset_TLT_846', prices))], 'top', int('1'))
rt.NODE_REGISTRY['_node_filter_847'] = _node_filter_847


def _node_wt_cash_equal_848(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_filter_847', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_848'] = _node_wt_cash_equal_848


def _node_if_849(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLK'], 10) > rt.relative_strength_index(prices['KMLM'], 10):
        return rt.call_node('_node_wt_cash_equal_844', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_848', prices)
rt.NODE_REGISTRY['_node_if_849'] = _node_if_849


def _node_wt_cash_equal_850(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_849', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_850'] = _node_wt_cash_equal_850


def _node_wt_cash_equal_851(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_850', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_851'] = _node_wt_cash_equal_851


def _node_wt_cash_equal_852(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_851', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_852'] = _node_wt_cash_equal_852


def _node_if_853(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPXL'], 10) < 30.0:
        return rt.call_node('_node_asset_SPXL_839', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_852', prices)
rt.NODE_REGISTRY['_node_if_853'] = _node_if_853


def _node_wt_cash_equal_854(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_853', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_854'] = _node_wt_cash_equal_854


def _node_if_855(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SOXL'], 10) < 30.0:
        return rt.call_node('_node_asset_SOXL_838', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_854', prices)
rt.NODE_REGISTRY['_node_if_855'] = _node_if_855


def _node_wt_cash_equal_856(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_855', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_856'] = _node_wt_cash_equal_856


def _node_if_857(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) < 30.0:
        return rt.call_node('_node_asset_TECL_837', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_856', prices)
rt.NODE_REGISTRY['_node_if_857'] = _node_if_857


def _node_wt_cash_equal_858(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_857', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_858'] = _node_wt_cash_equal_858


def _node_wt_cash_equal_859(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_858', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_859'] = _node_wt_cash_equal_859


def _node_if_860(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['UVXY'], 21) > 65.0:
        return rt.call_node('_node_wt_cash_equal_836', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_859', prices)
rt.NODE_REGISTRY['_node_if_860'] = _node_if_860


def _node_wt_cash_equal_861(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_860', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_861'] = _node_wt_cash_equal_861


def _node_wt_cash_equal_862(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_861', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_862'] = _node_wt_cash_equal_862


def _node_if_863(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['SPY'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_831', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_862', prices)
rt.NODE_REGISTRY['_node_if_863'] = _node_if_863


def _node_wt_cash_equal_864(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_863', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_864'] = _node_wt_cash_equal_864


def _node_if_865(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['FAS'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_830', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_864', prices)
rt.NODE_REGISTRY['_node_if_865'] = _node_if_865


def _node_wt_cash_equal_866(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_865', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_866'] = _node_wt_cash_equal_866


def _node_if_867(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLY'], 10) > 80.0:
        return rt.call_node('_node_asset_UVXY_829', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_866', prices)
rt.NODE_REGISTRY['_node_if_867'] = _node_if_867


def _node_wt_cash_equal_868(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_867', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_868'] = _node_wt_cash_equal_868


def _node_if_869(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TQQQ'], 10) > 79.0:
        return rt.call_node('_node_wt_cash_equal_828', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_868', prices)
rt.NODE_REGISTRY['_node_if_869'] = _node_if_869


def _node_wt_cash_equal_870(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_869', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_870'] = _node_wt_cash_equal_870


def _node_if_871(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['XLP'], 10) > 75.0:
        return rt.call_node('_node_asset_UVXY_826', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_870', prices)
rt.NODE_REGISTRY['_node_if_871'] = _node_if_871


def _node_wt_cash_equal_872(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_871', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_872'] = _node_wt_cash_equal_872


def _node_if_873(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IUSV'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_825', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_872', prices)
rt.NODE_REGISTRY['_node_if_873'] = _node_if_873


def _node_wt_cash_equal_874(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_873', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_874'] = _node_wt_cash_equal_874


def _node_if_875(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IVW'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_824', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_874', prices)
rt.NODE_REGISTRY['_node_if_875'] = _node_if_875


def _node_wt_cash_equal_876(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_875', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_876'] = _node_wt_cash_equal_876


def _node_if_877(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['TECL'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_823', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_876', prices)
rt.NODE_REGISTRY['_node_if_877'] = _node_if_877


def _node_wt_cash_equal_878(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_877', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_878'] = _node_wt_cash_equal_878


def _node_if_879(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VOX'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_822', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_878', prices)
rt.NODE_REGISTRY['_node_if_879'] = _node_if_879


def _node_wt_cash_equal_880(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_879', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_880'] = _node_wt_cash_equal_880


def _node_if_881(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['VTV'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_821', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_880', prices)
rt.NODE_REGISTRY['_node_if_881'] = _node_if_881


def _node_wt_cash_equal_882(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_881', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_882'] = _node_wt_cash_equal_882


def _node_if_883(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['QQQE'], 10) > 79.0:
        return rt.call_node('_node_asset_UVXY_820', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_882', prices)
rt.NODE_REGISTRY['_node_if_883'] = _node_if_883


def _node_wt_cash_equal_884(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_883', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_884'] = _node_wt_cash_equal_884


def _node_wt_cash_equal_885(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_884', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_885'] = _node_wt_cash_equal_885


def _node_asset_EDC_886(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_886'] = _node_asset_EDC_886


def _node_asset_BIL_887(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_887'] = _node_asset_BIL_887


def _node_wt_cash_specified_888(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('68') / float(100)), rt.call_node('_node_asset_EDC_886', prices)), ((float(32) / float(100)), rt.call_node('_node_asset_BIL_887', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_888'] = _node_wt_cash_specified_888


def _node_asset_EDC_889(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_889'] = _node_asset_EDC_889


def _node_asset_EDZ_890(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_890'] = _node_asset_EDZ_890


def _node_if_891(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEI'], 10) > rt.relative_strength_index(prices['IWM'], 15):
        return rt.call_node('_node_asset_EDC_889', prices)
    else:
        return rt.call_node('_node_asset_EDZ_890', prices)
rt.NODE_REGISTRY['_node_if_891'] = _node_if_891


def _node_wt_cash_equal_892(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_891', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_892'] = _node_wt_cash_equal_892


def _node_asset_EDC_893(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_893'] = _node_asset_EDC_893


def _node_asset_EDZ_894(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_894'] = _node_asset_EDZ_894


def _node_if_895(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 15) > rt.relative_strength_index(prices['EEM'], 15):
        return rt.call_node('_node_asset_EDC_893', prices)
    else:
        return rt.call_node('_node_asset_EDZ_894', prices)
rt.NODE_REGISTRY['_node_if_895'] = _node_if_895


def _node_wt_cash_equal_896(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_895', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_896'] = _node_wt_cash_equal_896


def _node_asset_EDC_897(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_897'] = _node_asset_EDC_897


def _node_asset_EDZ_898(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_898'] = _node_asset_EDZ_898


def _node_if_899(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EDC_897', prices)
    else:
        return rt.call_node('_node_asset_EDZ_898', prices)
rt.NODE_REGISTRY['_node_if_899'] = _node_if_899


def _node_wt_cash_equal_900(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_899', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_900'] = _node_wt_cash_equal_900


def _node_combine_equal_901(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_896', prices), rt.call_node('_node_wt_cash_equal_900', prices)])
rt.NODE_REGISTRY['_node_combine_equal_901'] = _node_combine_equal_901


def _node_if_902(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['EEM']) > rt.moving_average_price(prices['EEM'], 200):
        return rt.call_node('_node_wt_cash_equal_892', prices)
    else:
        return rt.call_node('_node_combine_equal_901', prices)
rt.NODE_REGISTRY['_node_if_902'] = _node_if_902


def _node_wt_cash_equal_903(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_902', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_903'] = _node_wt_cash_equal_903


def _node_asset_EDC_904(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_904'] = _node_asset_EDC_904


def _node_asset_EDZ_905(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_905'] = _node_asset_EDZ_905


def _node_if_906(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EDC_904', prices)
    else:
        return rt.call_node('_node_asset_EDZ_905', prices)
rt.NODE_REGISTRY['_node_if_906'] = _node_if_906


def _node_wt_cash_equal_907(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_906', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_907'] = _node_wt_cash_equal_907


def _node_if_908(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SHV']) > rt.moving_average_price(prices['SHV'], 50):
        return rt.call_node('_node_wt_cash_equal_903', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_907', prices)
rt.NODE_REGISTRY['_node_if_908'] = _node_if_908


def _node_wt_cash_equal_909(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_908', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_909'] = _node_wt_cash_equal_909


def _node_if_910(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['EEM'], 10) < 25.0:
        return rt.call_node('_node_wt_cash_specified_888', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_909', prices)
rt.NODE_REGISTRY['_node_if_910'] = _node_if_910


def _node_wt_cash_equal_911(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_910', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_911'] = _node_wt_cash_equal_911


def _node_wt_cash_equal_912(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_911', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_912'] = _node_wt_cash_equal_912


def _node_asset_EDC_913(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDC': 1.0}
rt.NODE_REGISTRY['_node_asset_EDC_913'] = _node_asset_EDC_913


def _node_asset_BIL_914(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_914'] = _node_asset_BIL_914


def _node_wt_cash_specified_915(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('68') / float(100)), rt.call_node('_node_asset_EDC_913', prices)), ((float(32) / float(100)), rt.call_node('_node_asset_BIL_914', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_915'] = _node_wt_cash_specified_915


def _node_asset_EEM_916(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_916'] = _node_asset_EEM_916


def _node_asset_EDZ_917(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_917'] = _node_asset_EDZ_917


def _node_asset_BIL_918(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_918'] = _node_asset_BIL_918


def _node_wt_cash_specified_919(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_917', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_918', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_919'] = _node_wt_cash_specified_919


def _node_if_920(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IEI'], 10) > rt.relative_strength_index(prices['IWM'], 15):
        return rt.call_node('_node_asset_EEM_916', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_919', prices)
rt.NODE_REGISTRY['_node_if_920'] = _node_if_920


def _node_wt_cash_equal_921(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_920', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_921'] = _node_wt_cash_equal_921


def _node_asset_EEM_922(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_922'] = _node_asset_EEM_922

# region imports
from AlgorithmImports import *
# endregion
from typing import Dict, Sequence

import strategy_runtime as rt


def _node_asset_EDZ_923(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_923'] = _node_asset_EDZ_923


def _node_asset_BIL_924(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_924'] = _node_asset_BIL_924


def _node_wt_cash_specified_925(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_923', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_924', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_925'] = _node_wt_cash_specified_925


def _node_if_926(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 15) > rt.relative_strength_index(prices['EEM'], 15):
        return rt.call_node('_node_asset_EEM_922', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_925', prices)
rt.NODE_REGISTRY['_node_if_926'] = _node_if_926


def _node_wt_cash_equal_927(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_926', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_927'] = _node_wt_cash_equal_927


def _node_asset_EEM_928(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_928'] = _node_asset_EEM_928


def _node_asset_EDZ_929(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_929'] = _node_asset_EDZ_929


def _node_asset_BIL_930(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_930'] = _node_asset_BIL_930


def _node_wt_cash_specified_931(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_929', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_930', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_931'] = _node_wt_cash_specified_931


def _node_if_932(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EEM_928', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_931', prices)
rt.NODE_REGISTRY['_node_if_932'] = _node_if_932


def _node_wt_cash_equal_933(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_932', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_933'] = _node_wt_cash_equal_933


def _node_combine_equal_934(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_927', prices), rt.call_node('_node_wt_cash_equal_933', prices)])
rt.NODE_REGISTRY['_node_combine_equal_934'] = _node_combine_equal_934


def _node_if_935(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['EEM']) > rt.moving_average_price(prices['EEM'], 200):
        return rt.call_node('_node_wt_cash_equal_921', prices)
    else:
        return rt.call_node('_node_combine_equal_934', prices)
rt.NODE_REGISTRY['_node_if_935'] = _node_if_935


def _node_wt_cash_equal_936(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_935', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_936'] = _node_wt_cash_equal_936


def _node_asset_EEM_937(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EEM': 1.0}
rt.NODE_REGISTRY['_node_asset_EEM_937'] = _node_asset_EEM_937


def _node_asset_EDZ_938(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'EDZ': 1.0}
rt.NODE_REGISTRY['_node_asset_EDZ_938'] = _node_asset_EDZ_938


def _node_asset_BIL_939(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return {'BIL': 1.0}
rt.NODE_REGISTRY['_node_asset_BIL_939'] = _node_asset_BIL_939


def _node_wt_cash_specified_940(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_weighted([((float('33') / float(100)), rt.call_node('_node_asset_EDZ_938', prices)), ((float(67) / float(100)), rt.call_node('_node_asset_BIL_939', prices))])
rt.NODE_REGISTRY['_node_wt_cash_specified_940'] = _node_wt_cash_specified_940


def _node_if_941(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['IGIB'], 10) > rt.relative_strength_index(prices['SPY'], 10):
        return rt.call_node('_node_asset_EEM_937', prices)
    else:
        return rt.call_node('_node_wt_cash_specified_940', prices)
rt.NODE_REGISTRY['_node_if_941'] = _node_if_941


def _node_wt_cash_equal_942(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_941', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_942'] = _node_wt_cash_equal_942


def _node_if_943(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SHV']) > rt.moving_average_price(prices['SHV'], 50):
        return rt.call_node('_node_wt_cash_equal_936', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_942', prices)
rt.NODE_REGISTRY['_node_if_943'] = _node_if_943


def _node_wt_cash_equal_944(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_943', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_944'] = _node_wt_cash_equal_944


def _node_if_945(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.relative_strength_index(prices['EEM'], 10) < 25.0:
        return rt.call_node('_node_wt_cash_specified_915', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_944', prices)
rt.NODE_REGISTRY['_node_if_945'] = _node_if_945


def _node_wt_cash_equal_946(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_945', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_946'] = _node_wt_cash_equal_946


def _node_wt_cash_equal_947(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_946', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_947'] = _node_wt_cash_equal_947


def _node_if_948(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    if rt.current_price(prices['SPY']) > rt.moving_average_price(prices['SPY'], 200):
        return rt.call_node('_node_wt_cash_equal_912', prices)
    else:
        return rt.call_node('_node_wt_cash_equal_947', prices)
rt.NODE_REGISTRY['_node_if_948'] = _node_if_948


def _node_wt_cash_equal_949(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_if_948', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_949'] = _node_wt_cash_equal_949


def _node_wt_cash_equal_950(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_949', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_950'] = _node_wt_cash_equal_950


def _node_wt_cash_equal_951(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_819', prices), rt.call_node('_node_wt_cash_equal_885', prices), rt.call_node('_node_wt_cash_equal_950', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_951'] = _node_wt_cash_equal_951


def _node_wt_cash_equal_952(prices: Dict[str, Sequence[float]]) -> Dict[str, float]:
    return rt.combine_equal([rt.call_node('_node_wt_cash_equal_331', prices), rt.call_node('_node_wt_cash_equal_661', prices), rt.call_node('_node_wt_cash_equal_951', prices)])
rt.NODE_REGISTRY['_node_wt_cash_equal_952'] = _node_wt_cash_equal_952