group_neutralize(ts_sum(if_else(implied_volatility_mean_10 > implied_volatility_mean_20, returns, -returns), 5), sector)

group_neutralize(ts_delta(log(volume), 10) * ts_rank(close, 20), sector)

group_neutralize(ts_corr(returns, scl12_sentiment, 30) * ts_std_dev(returns, 60), sector)

if_else(volume > ts_mean(volume, 30), ts_rank(returns, 10), -ts_rank(returns, 10))

ts_sum(if_else(ts_rank(close, 5) > ts_rank(close, 20), ts_delta(close, 1), -ts_delta(close, 1)), 10)

group_neutralize(ts_rank(ts_corr(vwap, volume, 20), 5), sector)

ts_av_diff(implied_volatility_mean_180, 30) * ts_zscore(returns, 60)

group_neutralize(ts_rank(pcr_oi_30, 10) * ts_delta(close, 5), sector)

ts_sum(signed_power(ts_delta(log(close), 2), sign(ts_delta(volume, 2))), 5)

scale(ts_rank(close, 10) - ts_rank(vwap, 10))

if_else(ts_std_dev(returns, 30) > ts_mean(ts_std_dev(returns, 5), 30), ts_rank(close, 5), ts_rank(-close, 5))

group_neutralize(ts_rank(ts_delta(close, 2), 10) * ts_sum(volume, 5), sector)

ts_delta(ts_corr(close, volume, 10), 5) * ts_scale(close, 20)

group_neutralize(ts_rank(fscore_momentum, 60) * ts_zscore(returns, 30), sector)

ts_sum(if_else(ts_rank(close, 20) > ts_rank(vwap, 20), log(volume), -log(volume)), 15)

if_else(historical_volatility_60 > ts_mean(historical_volatility_60, 60), ts_rank(returns, 10), ts_rank(-returns, 10))

ts_regression(returns, ts_delta(scl12_sentiment, 1), 30, 0, 0)

group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(pcr_vol_10, 1))), 5), sector)

ts_av_diff(implied_volatility_mean_skew_30, 20) * ts_zscore(close, 50)

if_else(ts_mean(volume, 10) > ts_mean(volume, 30), ts_rank(close, 5), -ts_rank(close, 10))

group_neutralize(ts_rank(ts_corr(fscore_value, returns, 40), 10), sector)

ts_sum(if_else(ts_delta(log(volume), 5) > 0, ts_delta(close, 1), -ts_delta(close, 1)), 8)

ts_corr(ts_rank(close, 5), ts_rank(volume, 20), 10)

group_neutralize(ts_rank(ts_delta(vwap, 3), 15) * ts_std_dev(returns, 20), sector)

if_else(pcr_oi_90 > ts_mean(pcr_oi_90, 30), ts_rank(returns, 10), -ts_rank(returns, 10))

ts_av_diff(fscore_growth, 20) * ts_zscore(ts_delta(close, 2), 40)

group_neutralize(ts_rank(ts_corr(implied_volatility_call_30, returns, 30), 10), sector)

ts_sum(signed_power(ts_delta(vwap, 1), sign(ts_delta(fscore_profitability, 5))), 10)

scale(ts_rank(ts_sum(returns, 5), 20) - ts_rank(ts_sum(volume, 5), 20))

if_else(beta_last_30_days_spy > ts_mean(beta_last_30_days_spy, 60), ts_rank(close, 5), ts_rank(-close, 10))

group_neutralize(ts_rank(ts_delta(fscore_quality, 10), 20) * ts_zscore(returns, 30), sector)

ts_delta(ts_corr(close, parkinson_volatility_30, 20), 5) * ts_scale(close, 15)

group_neutralize(ts_rank(rp_css_earnings, 40) * ts_delta(close, 3), sector)

ts_sum(if_else(ts_rank(close, 15) > ts_rank(volume, 15), ts_delta(close, 1), -ts_delta(close, 1)), 10)

if_else(implied_volatility_mean_360 > ts_mean(implied_volatility_mean_360, 90), ts_rank(returns, 15), ts_rank(-returns, 15))

ts_regression(returns, ts_delta(rp_nip_price, 1), 25, 0, 0)

group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(call_breakeven_30, 1))), 5), sector)

ts_av_diff(implied_volatility_mean_skew_120, 30) * ts_zscore(returns, 50)

if_else(ts_mean(adv20, 10) > ts_mean(adv20, 30), ts_rank(close, 8), -ts_rank(close, 12))

group_neutralize(ts_rank(ts_corr(forward_price_60, returns, 35), 10), sector)

ts_sum(if_else(ts_delta(log(adv20), 5) > 0, ts_delta(close, 1), -ts_delta(close, 1)), 12)

ts_corr(ts_rank(vwap, 8), ts_rank(pcr_vol_20, 25), 15)

group_neutralize(ts_rank(ts_delta(put_breakeven_30, 5), 20) * ts_std_dev(returns, 25), sector)

if_else(pcr_vol_30 > ts_mean(pcr_vol_30, 30), ts_rank(returns, 10), -ts_rank(returns, 10))

ts_av_diff(fscore_total, 25) * ts_zscore(ts_delta(close, 3), 60)

group_neutralize(ts_rank(ts_corr(implied_volatility_call_90, returns, 40), 10), sector)

ts_sum(signed_power(ts_delta(close, 2), sign(ts_delta(fscore_surface_accel, 7))), 8)

scale(ts_rank(ts_sum(returns, 7), 25) - ts_rank(ts_sum(adv20, 7), 25))

if_else(beta_last_90_days_spy > ts_mean(beta_last_90_days_spy, 90), ts_rank(close, 10), ts_rank(-close, 15))

group_neutralize(ts_rank(ts_delta(systematic_risk_last_30_days, 15), 30) * ts_zscore(returns, 40), sector)

ts_delta(ts_corr(close, nws18_nip, 25), 7) * ts_scale(close, 20)

group_neutralize(ts_rank(rp_css_ptg, 50) * ts_delta(close, 4), sector)

ts_sum(if_else(ts_rank(vwap, 20) > ts_rank(adv20, 20), ts_delta(close, 1), -ts_delta(close, 1)), 15)

if_else(implied_volatility_mean_720 > ts_mean(implied_volatility_mean_720, 120), ts_rank(returns, 20), ts_rank(-returns, 20))

ts_regression(returns, ts_delta(scl12_buzz, 1), 20, 0, 0)

group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(option_breakeven_90, 1))), 6), sector)

ts_av_diff(implied_volatility_mean_skew_10, 15) * ts_zscore(returns, 30)

if_else(ts_mean(volume, 15) > ts_mean(volume, 45), ts_rank(close, 10), -ts_rank(close, 20))

group_neutralize(ts_rank(ts_corr(forward_price_180, returns, 45), 10), sector)

ts_sum(if_else(ts_delta(log(volume), 7) > 0, ts_delta(close, 2), -ts_delta(close, 2)), 10)

ts_corr(ts_rank(close, 10), ts_rank(pcr_oi_120, 30), 20)

group_neutralize(ts_rank(ts_delta(call_breakeven_180, 7), 25) * ts_std_dev(returns, 30), sector)

if_else(pcr_vol_270 > ts_mean(pcr_vol_270, 30), ts_rank(returns, 12), -ts_rank(returns, 12))

ts_av_diff(fscore_surface, 30) * ts_zscore(ts_delta(close, 4), 70)

group_neutralize(ts_rank(ts_corr(implied_volatility_call_270, returns, 50), 10), sector)

ts_sum(signed_power(ts_delta(vwap, 2), sign(ts_delta(fscore_momentum, 10))), 12)

scale(ts_rank(ts_sum(returns, 10), 30) - ts_rank(ts_sum(pcr_oi_20, 10), 30))

if_else(unsystematic_risk_last_60_days > ts_mean(unsystematic_risk_last_60_days, 120), ts_rank(close, 12), ts_rank(-close, 18))

group_neutralize(ts_rank(ts_delta(beta_last_60_days_spy, 20), 35) * ts_zscore(returns, 45), sector)

ts_delta(ts_corr(close, rp_ess_price, 30), 10) * ts_scale(close, 25)

group_neutralize(ts_rank(rp_css_dividends, 60) * ts_delta(close, 5), sector)

ts_sum(if_else(ts_rank(close, 25) > ts_rank(volume, 25), ts_delta(close, 2), -ts_delta(close, 2)), 20)

if_else(parkinson_volatility_90 > ts_mean(parkinson_volatility_90, 60), ts_rank(returns, 15), ts_rank(-returns, 15))

ts_regression(returns, ts_delta(fscore_profitability, 2), 35, 0, 0)

group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(put_breakeven_270, 1))), 7), sector)

ts_av_diff(implied_volatility_mean_150, 40) * ts_zscore(returns, 60)

if_else(ts_mean(adv20, 20) > ts_mean(adv20, 60), ts_rank(close, 15), -ts_rank(close, 25))

group_neutralize(ts_rank(ts_corr(forward_price_720, returns, 60), 10), sector)

ts_sum(if_else(ts_delta(log(adv20), 10) > 0, ts_delta(close, 3), -ts_delta(close, 3)), 15)

ts_corr(ts_rank(vwap, 12), ts_rank(pcr_vol_360, 40), 25)

group_neutralize(ts_rank(ts_delta(option_breakeven_720, 10), 30) * ts_std_dev(returns, 35), sector)

if_else(pcr_oi_270 > ts_mean(pcr_oi_270, 30), ts_rank(returns, 15), -ts_rank(returns, 15))

ts_av_diff(fscore_bfl_surface_accel, 35) * ts_zscore(ts_delta(close, 5), 80)

group_neutralize(ts_rank(ts_corr(implied_volatility_call_1080, returns, 70), 10), sector)

ts_sum(signed_power(ts_delta(close, 3), sign(ts_delta(analyst_revision_rank_derivative, 15))), 15)

scale(ts_rank(ts_sum(returns, 12), 35) - ts_rank(ts_sum(pcr_oi_90, 12), 35))

if_else(correlation_last_90_days_spy > ts_mean(correlation_last_90_days_spy, 180), ts_rank(close, 15), ts_rank(-close, 22))

group_neutralize(ts_rank(ts_delta(systematic_risk_last_90_days, 25), 40) * ts_zscore(returns, 50), sector)

ts_delta(ts_corr(close, nws18_acb, 35), 12) * ts_scale(close, 30)

group_neutralize(ts_rank(rp_css_assets, 70) * ts_delta(close, 6), sector)

ts_sum(if_else(ts_rank(vwap, 30) > ts_rank(volume, 30), ts_delta(close, 3), -ts_delta(close, 3)), 25)

if_else(historical_volatility_150 > ts_mean(historical_volatility_150, 90), ts_rank(returns, 18), ts_rank(-returns, 18))

ts_regression(returns, ts_delta(fscore_growth, 3), 40, 0, 0)

group_neutralize(ts_sum(signed_power(ts_delta(close, 2), sign(ts_delta(call_breakeven_270, 2))), 8), sector)

ts_av_diff(implied_volatility_mean_360, 50) * ts_zscore(returns, 70)

if_else(ts_mean(volume, 25) > ts_mean(volume, 75), ts_rank(close, 20), -ts_rank(close, 30))

group_neutralize(ts_rank(ts_corr(forward_price_120, returns, 80), 10), sector)

ts_sum(if_else(ts_delta(log(volume), 12) > 0, ts_delta(close, 4), -ts_delta(close, 4)), 20)

ts_corr(ts_rank(close, 15), ts_rank(pcr_oi_720, 50), 30)

group_neutralize(ts_rank(ts_delta(put_breakeven_150, 12), 35) * ts_std_dev(returns, 40), sector)

if_else(pcr_vol_30 > 1, ts_rank(returns, 18), -ts_rank(returns, 18))

ts_av_diff(fscore_bfl_total, 40) * ts_zscore(ts_delta(close, 6), 90)


ts_rank(volume, 20) * ts_rank(returns, 20)

ts_delta(volume, 5) / ts_mean(volume, 20)

log(volume) * ts_rank(close, 10)

ts_rank(adv20, 60) - ts_rank(returns, 60)

ts_corr(volume, returns, 20)

ts_rank(multiply(volume, returns), 20)

sign(ts_delta(volume, 10)) * (-1 * ts_rank(returns, 10))

ts_rank(low, 5) - ts_rank(volume, 5)

ts_mean(volume, 5) / ts_mean(volume, 60)

rank(volume) - rank(returns)

ts_delta(log(volume), 5)

multiply(ts_rank(volume, 20), ts_delta(close, 20))

ts_mean(returns, 20) * ts_std_dev(volume, 20)

divide(ts_sum(volume, 5), ts_sum(volume, 20))

ts_rank(close, 20) / ts_rank(volume, 20)

ts_corr(ts_delta(close, 1), ts_delta(volume, 1), 5)

rank(ts_delta(close, 5)) * rank(volume)

ts_mean(divide(ts_delta(high, 1), close), 10) * rank(volume)

multiply(rank(volume), rank(close))

ts_rank(volume, 10) * ts_std_dev(returns, 10)

ts_zscore(volume, 60) * ts_rank(returns, 20)

ts_mean(rank(volume), 10) * sign(ts_delta(close, 10))

ts_delta(rank(volume), 20) * rank(returns)

inverse(rank(volume)) * ts_rank(returns, 5)

ts_mean(ts_delta(close, 1), 10) * rank(volume)

multiply(sign(ts_delta(close, 10)), ts_rank(volume, 20))

ts_coeff(returns, ts_mean(volume, 20), 10)

divide(ts_rank(volume, 10), ts_rank(volume, 60))

rank(multiply(volume, returns))

ts_mean(volume, 3) - ts_mean(volume, 20)

multiply(ts_rank(volume, 20), ts_rank(ts_delta(close, 20), 20))

ts_corr(rank(volume), rank(close), 20)

ts_mean(returns, 20) / ts_mean(volume, 20)

ts_rank(volume, 20) - ts_rank(volume, 60)

rank(volume) * rank(ts_delta(close, 10))

multiply(ts_rank(volume, 20), ts_corr(close, volume, 20))

divide(ts_sum(volume, 20), cap)

ts_mean(returns, 20) * ts_mean(volume, 20)

rank(returns) - rank(volume)

ts_delta(log(volume), 10) * rank(returns)

ts_mean(rank(volume), 20) * rank(close)

multiply(ts_std_dev(returns, 20), ts_std_dev(volume, 20))

ts_rank(volume, 20) * ts_mean(ts_delta(close, 1), 10)

divide(ts_mean(volume, 20), adv20)

rank(volume) + rank(returns)

ts_delta(volume, 20) * ts_std_dev(returns, 20)

multiply(rank(close), rank(volume))

ts_rank(returns, 20) / ts_rank(volume, 20)

ts_mean(ts_corr(close, volume, 10), 20)

ts_rank(volume, 20) * ts_rank(ts_delta(close, 5), 10)

rank(multiply(returns, volume))

ts_mean(returns, 20) * rank(volume)

ts_rank(volume, 60) - ts_rank(returns, 20)

multiply(ts_rank(volume, 20), ts_mean(ts_delta(close, 1), 5))

ts_corr(rank(volume), rank(returns), 20)

divide(ts_delta(volume, 10), ts_mean(volume, 60))

rank(volume) * rank(ts_delta(close, 20))

multiply(ts_std_dev(volume, 20), ts_rank(returns, 20))

ts_mean(rank(volume), 20) * rank(returns)

ts_rank(volume, 20) - ts_rank(close, 20)

rank(volume) * ts_std_dev(returns, 20)

ts_rank(multiply(volume, ts_delta(close, 10)), 20)

ts_mean(returns, 20) / rank(volume)

multiply(ts_rank(volume, 20), ts_corr(ts_delta(close, 1), ts_delta(volume, 1), 20))

divide(ts_sum(volume, 20), ts_sum(volume, 60))

rank(volume) * rank(returns) * -1

ts_delta(volume, 20) * ts_rank(close, 20)

ts_mean(rank(volume), 20) - rank(close)

multiply(ts_corr(close, volume, 20), ts_rank(returns, 20))

divide(ts_std_dev(volume, 20), ts_mean(volume, 20))

ts_rank(volume, 20) * ts_zscore(returns, 20)

multiply(rank(volume), rank(ts_delta(close, 5)))

ts_mean(ts_corr(close, volume, 10), 20) * rank(returns)

ts_rank(volume, 60) / ts_rank(close, 20)

(rank(volume) > rank(returns)) * (-1)

ts_delta(volume, 10) * ts_corr(close, volume, 20)

divide(ts_mean(volume, 10), adv20) * -1

multiply(rank(volume), rank(ts_delta(close, 20)))

ts_std_dev(returns, 20) * ts_rank(volume, 20)

rank(volume) - rank(close) * -1

multiply(ts_mean(ts_delta(close, 1), 10), rank(volume))

ts_corr(rank(returns), rank(volume), 20)

ts_rank(volume, 20) * ts_mean(rank(close), 20)

divide(ts_sum(volume, 10), ts_sum(volume, 20))

rank(volume) * rank(ts_delta(close, 10)) * -1

ts_delta(volume, 20) * ts_mean(returns, 20)

multiply(rank(volume), rank(returns))

ts_rank(volume, 20) * ts_rank(ts_delta(close, 20), 20) * -1

divide(ts_std_dev(volume, 20), ts_std_dev(returns, 20))

rank(volume) + rank(ts_delta(close, 20))

multiply(ts_corr(close, volume, 20), rank(volume))

ts_mean(returns, 20) * ts_mean(rank(volume), 20)

ts_rank(volume, 20) - ts_delta(close, 20)

rank(volume) * ts_zscore(returns, 20)

multiply(ts_rank(volume, 20), ts_corr(rank(close), rank(volume), 20))

divide(ts_delta(volume, 20), ts_mean(volume, 20))

rank(volume) * ts_rank(returns, 20) * -1

ts_delta(volume, 10) * ts_mean(ts_delta(close, 1), 10)

multiply(rank(volume), rank(ts_delta(close, 20))) * -1

ts_std_dev(returns, 20) / ts_std_dev(volume, 20)

rank(ts_delta(close, 5) / ts_std_dev(close, 30), 2) * sign(ts_delta(close, 10))

scale(ts_mean(volume, 20) / ts_mean(volume, 60), 1) - ts_delta(cap, 21) / cap

rank(ts_corr(ts_delta(close, 1), volume, 20), 2) * (ts_mean(close, 5) > ts_mean(close, 20))

ts_zscore(close, 30) * (1 - ts_count_nans(close, 5))

ts_decay_linear(close, 20) * (ts_mean(volume, 10) > ts_mean(volume, 40))

(ts_mean(close, 10) - ts_mean(close, 40)) / ts_std_dev(close, 90) * (volume > ts_mean(volume, 20))

rank(ts_arg_max(close, 30), 2) * -sign(ts_delta(close, 5))

(ts_delay(close, 5) - ts_delay(close, 20)) / ts_delay(close, 20) * ts_mean(volume, 10)

rank(ts_corr(returns, ts_mean(returns, 10), 20), 2) * (ts_std_dev(returns, 10) < 0.02)

ts_scale(ts_delta(close, 1), 1) * (ts_mean(volume, 5) > ts_mean(volume, 25))

(ts_delta(close, 5) / ts_std_dev(close, 30)) * ts_decay_linear(volume, 20)

rank(ts_backfill(fclose, 20, 1), 2) * sign(ts_delta(close, 1))

(ts_mean(close, 60) - ts_mean(close, 120)) / ts_std_dev(close, 180) * (ts_mean(volume, 60) > ts_mean(volume, 120))

(1 - ts_rank(close, 20)) * (ts_delay(close, 1) < ts_mean(close, 30))

ts_delta(ts_mean(close, 10), 30) * ts_std_dev(returns, 10)

rank(ts_delta(close, 10), 2) * (volume > ts_mean(volume, 20))

(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_std_dev(volume, 10)

ts_zscore(ts_delta(close, 5), 10) * (ts_mean(close, 5) < ts_mean(close, 20))

rank(ts_corr(close, ts_mean(close, 20), 60), 2) * ts_delay(volume, 1)

(ts_mean(close, 20) < ts_mean(close, 100)) * (ts_delta(close, 5) > 0.02)

rank(ts_delay(close, 5), 2) * (ts_delta(close, 15) / ts_std_dev(close, 30))

scale(ts_delta(volume, 10), 1) * (ts_corr(close, ts_mean(close, 30), 20) < 0.5)

ts_decay_linear(ts_delta(close, 1), 20) * (ts_rank(volume, 10) > 0.8)

rank(ts_corr(ts_delay(close, 5), ts_delay(close, 20), 30), 2) * (ts_std_dev(returns, 5) > 0.03)

(ts_delta(close, 20) / ts_std_dev(close, 60)) * (ts_mean(volume, 20) < ts_mean(volume, 100))

(1 - ts_rank(close, 30)) * (ts_delta(close, 10) < -0.01)

rank(ts_delta(ts_mean(high, 5), 10), 2) * (volume > ts_mean(volume, 20))

ts_zscore(ts_delta(ts_mean(close, 5), 20), 60) * (ts_rank(volume, 20) > 0.7)

(ts_corr(close, ts_mean(close, 10), 30) < 0.3) * ts_delta(close, 20)

rank(ts_backfill(close, 10, 1), 2) * sign(ts_delta(close, 5))

(ts_mean(high, 10) - ts_mean(low, 10)) / ts_mean(close, 10) * ts_volume(10)

rank(ts_arg_min(close, 30), 2) * (ts_delta(close, 5) < 0)

(ts_delta(close, 5) / ts_delay(close, 5)) * ts_decay_linear(volume, 20)

rank(ts_corr(returns, volume, 20), 2) * (ts_std_dev(returns, 20) > 0.025)

(ts_delay(close, 20) - ts_delay(close, 60)) / ts_delay(close, 60) * ts_mean(volume, 20)

ts_zscore(ts_delta(ts_mean(close, 20), 60), 90) * (ts_rank(close, 30) < 0.3)

(ts_delta(close, 10) > 0.02) * (ts_mean(volume, 5) / ts_mean(volume, 60) > 1.5)

rank(ts_corr(ts_delay(close, 10), ts_delay(close, 40), 60), 2) * (ts_std_dev(volume, 10) > 0.01)

ts_scale(ts_delta(close, 20), 1) * (ts_mean(close, 20) < ts_mean(close, 100))

(1 - ts_rank(close, 60)) * (ts_delta(close, 15) > 0)

ts_delta(ts_mean(close, 30), 90) * ts_std_dev(returns, 30)

rank(ts_arg_max(close, 90), 2) * sign(ts_delta(close, 10))

(ts_delay(close, 10) - ts_delay(close, 30)) / ts_delay(close, 30) * ts_mean(volume, 10)

ts_zscore(ts_delta(ts_mean(close, 10), 30), 60) * (ts_rank(volume, 30) > 0.8)

(ts_corr(close, ts_mean(close, 60), 120) < 0.4) * ts_delta(close, 30)

rank(ts_backfill(close, 30, 1), 2) * sign(ts_delta(close, 10))

(ts_mean(high, 20) - ts_mean(low, 20)) / ts_mean(close, 20) * ts_volume(20)

rank(ts_arg_min(close, 60), 2) * (ts_delta(close, 5) < 0)

(ts_delta(close, 5) / ts_delay(close, 5)) * ts_decay_linear(volume, 30)

rank(ts_corr(returns, volume, 30), 2) * (ts_std_dev(returns, 30) > 0.03)

(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_mean(volume, 30)

ts_zscore(ts_delta(ts_mean(close, 60), 120), 180) * (ts_rank(close, 60) < 0.2)

(ts_delta(close, 20) > 0.02) * (ts_mean(volume, 10) / ts_mean(volume, 120) > 1.5)

rank(ts_corr(ts_delay(close, 20), ts_delay(close, 80), 120), 2) * (ts_std_dev(volume, 20) > 0.02)

ts_scale(ts_delta(close, 40), 1) * (ts_mean(close, 40) < ts_mean(close, 160))

(1 - ts_rank(close, 90)) * (ts_delta(close, 30) > 0)

ts_delta(ts_mean(close, 60), 180) * ts_std_dev(returns, 60)

rank(ts_arg_max(close, 180), 2) * sign(ts_delta(close, 20))

(ts_delay(close, 20) - ts_delay(close, 60)) / ts_delay(close, 60) * ts_mean(volume, 20)

ts_zscore(ts_delta(ts_mean(close, 20), 60), 120) * (ts_rank(volume, 60) > 0.7)

(ts_corr(close, ts_mean(close, 120), 250) < 0.5) * ts_delta(close, 60)

rank(ts_backfill(close, 60, 1), 2) * sign(ts_delta(close, 20))

(ts_mean(high, 60) - ts_mean(low, 60)) / ts_mean(close, 60) * ts_volume(60)

rank(ts_arg_min(close, 120), 2) * (ts_delta(close, 10) < 0)

(ts_delta(close, 10) / ts_delay(close, 10)) * ts_decay_linear(volume, 60)

rank(ts_corr(returns, volume, 60), 2) * (ts_std_dev(returns, 60) > 0.04)

(ts_delay(close, 60) - ts_delay(close, 180)) / ts_delay(close, 180) * ts_mean(volume, 60)

ts_zscore(ts_delta(ts_mean(close, 120), 360), 720) * (ts_rank(close, 120) < 0.1)

(ts_delta(close, 30) > 0.03) * (ts_mean(volume, 20) / ts_mean(volume, 240) > 2.0)

rank(ts_corr(ts_delay(close, 30), ts_delay(close, 120), 180), 2) * (ts_std_dev(volume, 30) > 0.03)

ts_scale(ts_delta(close, 80), 1) * (ts_mean(close, 80) < ts_mean(close, 320))

(1 - ts_rank(close, 180)) * (ts_delta(close, 90) > 0)

ts_delta(ts_mean(close, 120), 360) * ts_std_dev(returns, 120)

rank(ts_arg_max(close, 360), 2) * sign(ts_delta(close, 30))

(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_mean(volume, 30)

ts_zscore(ts_delta(ts_mean(close, 40), 120), 240) * (ts_rank(volume, 120) > 0.75)

(ts_corr(close, ts_mean(close, 240), 500) < 0.6) * ts_delta(close, 90)

rank(ts_backfill(close, 90, 1), 2) * sign(ts_delta(close, 30))

(ts_mean(high, 120) - ts_mean(low, 120)) / ts_mean(close, 120) * ts_volume(120)

rank(ts_arg_min(close, 240), 2) * (ts_delta(close, 20) < 0)

(ts_delta(close, 20) / ts_delay(close, 20)) * ts_decay_linear(volume, 120)

rank(ts_corr(returns, volume, 120), 2) * (ts_std_dev(returns, 120) > 0.05)

(ts_delay(close, 120) - ts_delay(close, 360)) / ts_delay(close, 360) * ts_mean(volume, 120)

ts_zscore(ts_delta(ts_mean(close, 240), 720), 1440) * (ts_rank(close, 240) < 0.05)

(ts_delta(close, 60) > 0.04) * (ts_mean(volume, 40) / ts_mean(volume, 480) > 2.5)

rank(ts_corr(ts_delay(close, 60), ts_delay(close, 240), 360), 2) * (ts_std_dev(volume, 60) > 0.04)

ts_scale(ts_delta(close, 160), 1) * (ts_mean(close, 160) < ts_mean(close, 640))

(1 - ts_rank(close, 360)) * (ts_delta(close, 180) > 0)

ts_delta(ts_mean(close, 180), 540) * ts_std_dev(returns, 180)

rank(ts_arg_max(close, 540), 2) * sign(ts_delta(close, 60))

(ts_delay(close, 60) - ts_delay(close, 180)) / ts_delay(close, 180) * ts_mean(volume, 60)

ts_zscore(ts_delta(ts_mean(close, 60), 180), 360) * (ts_rank(volume, 180) > 0.8)

(ts_corr(close, ts_mean(close, 360), 720) < 0.7) * ts_delta(close, 180)

rank(ts_backfill(close, 180, 1), 2) * sign(ts_delta(close, 60))

(ts_mean(high, 180) - ts_mean(low, 180)) / ts_mean(close, 180) * ts_volume(180)

rank(ts_arg_min(close, 360), 2) * (ts_delta(close, 40) < 0)

(ts_delta(close, 40) / ts_delay(close, 40)) * ts_decay_linear(volume, 180)

rank(ts_corr(returns, volume, 180), 2) * (ts_std_dev(returns, 180) > 0.06)

(ts_delay(close, 180) - ts_delay(close, 540)) / ts_delay(close, 540) * ts_mean(volume, 180)

ts_zscore(ts_delta(ts_mean(close, 360), 1080), 2160) * (ts_rank(close, 360) < 0.03)

(ts_delta(close, 90) > 0.05) * (ts_mean(volume, 60) / ts_mean(volume, 720) > 3.0)

rank(ts_corr(ts_delay(close, 90), ts_delay(close, 360), 540), 2) * (ts_std_dev(volume, 90) > 0.05)

ts_scale(ts_delta(close, 240), 1) * (ts_mean(close, 240) < ts_mean(close, 960))

(1 - ts_rank(close, 540)) * (ts_delta(close, 270) > 0)

ts_delta(ts_mean(close, 270), 810) * ts_std_dev(returns, 270)

rank(ts_arg_max(close, 810), 2) * sign(ts_delta(close, 90))

(ts_delay(close, 90) - ts_delay(close, 270)) / ts_delay(close, 270) * ts_mean(volume, 90)

ts_zscore(ts_delta(ts_mean(close, 90), 270), 540) * (ts_rank(volume, 270) > 0.85)

(ts_corr(close, ts_mean(close, 540), 1080) < 0.75) * ts_delta(close



add(returns, ts_delay(returns,1))

multiply(returns, inverse(volume))

divide(multiply(returns, vwap), cap)

group_zscore(returns, sector)

ts_mean(multiply(returns, volume),5)

if_else(volume > ts_mean(volume,30), 1, 0)

scale(returns,1,0)

winsorize(returns)

add(zscore(returns), zscore(adv20))

multiply(zscore(returns), ts_mean(returns,20))

group_neutralize(returns, sector)

group_backfill(returns, sector,30)

divide(returns, beta_last_30_days_spy)

multiply(returns, fscore_surface)

ts_corr(close, adv20,20)

add(ts_delay(returns,1), ts_delay(returns,2))

multiply( adv20, 0.01 )

subtract( ts_mean(returns,20), multiply(adv20,0.001))

add(zscore(adv20), zscore(volume))

ts_zscore(multiply(returns, volume),60)

if_else( snt_value > 0.7, -1, 1 ) * returns

divide( nws12_allz_result1, close )

ts_delay( snt_value, 1) * returns

add( normalize(returns), group_neutralize(beta_last_30_days_spy, sector) )

multiply( group_zscore(fscore_momentum, sector), returns )

group_zscore(fscore_surface, sector)

group_zscore(fscore_value, sector)

scale( fscore_value, 1, 0 )

ts_corr( close, snt_value,30 )

multiply( snt_value, ts_delay(returns,5) )

add( ts_delay(snt_value,1), ts_delay(snt_value,2) )

divide( call_breakeven_20, put_breakeven_20 )

ts_mean( divide( call_breakeven_30, put_breakeven_30 ),10)

if_else( pcr_vol_20 > 1.2, 1, -1 ) * returns

multiply( pcr_oi_60, returns )

group_zscore( pcr_oi_60, sector )

add( zscore( pcr_oi_60 ), zscore( adv20 ) )

ts_delay( pcr_oi_60,1) * returns

group_mean( sales, pv13_revere_company )

divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) )

multiply( fscore_surface, fscore_momentum )

if_else( fscore_surface > 50, 1, 0 ) * returns

normalize( fscore_surface )

ts_rank( fscore_surface,60 )

ts_delay( fscore_surface,30 )

multiply( ts_delay(returns,10), ts_rank( fscore_bfl_total,60 ) )

add( ts_delay(fscore_total,30), returns )

divide( fscore_value, fscore_growth )

group_scale(adv20, sector)

multiply( group_zscore(adv20, sector), returns )

ts_corr( adv20, snt_value,60 )

ts_covariance( adv20, returns,60 )

add( returns, multiply( adv20, 0.001 ) )

add( multiply(returns, volume), ts_delay(returns,1) )

multiply( adv20, beta_last_30_days_spy )

group_zscore( beta_last_30_days_spy, sector )

scale(div ide(returns, adv20),1,0 )

winsorize(multiply(returns, volume))

if_else( volume > adv20 * 2, 1, -1 ) * returns

add( snt_value, ts_delay(snt_value,1) )

scale( snt_social_volume, 1, 0 )

if_else( is_nan(close), group_mean(close, sector ), close )

group_backfill(close, sector,30)

ad d( ts_mean(returns,5), ts_mean(returns,10) )

add( ts_mean(returns,5), ts_mean(returns,10) )

scale(returns, longscale=1, shortscale=1 )

winsorize(group_zscore(returns, pv13_revere_key_sector))

ts_delay( volume,1 )

ts_mean( volume,10 )

if_else( ts_std_dev(returns,30) > 0.15, ts_delta(close,5), ts_delta(close,30))

divide( fscore_bfl_tota, fscore_bfl_value )

add( normalize(returns), group_neutralize(beta_last_30_days_spy, sector) )

multiply( group_zscore(returns, pv13_revere_company ), returns )

add( ts_delta(close, 5), ts_delta(close,10) )

multiply( snt_social_volume, 10 )

normalize( snt_social_value )

scale( snt_social_value, 1, 0 )

if_else( nws12_prez_02l > 0, 1, -1 ) * returns

ts_corr( close, volume,20 )

add( zscore(adv20), zscore(volume) )

group_mean( fscore_surface, pv13_revere_company )

divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) )

multiply( group_zscore(returns, pv13_revere_company), fscore_surface )

if_else( group_zscore(fscore_surface, sector) > 0.5, 1, -1 ) * returns

ts_mean( divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) ),5)

add( normalize( fscore_surface ), normalize( fscore_momentum ) )

multiply( snt_value, ts_delay(returns,1) )

add( ts_delay(snt_value,1), ts_delay(snt_value,2) )

if_else( pcr_oi_60 > 0.5, 1, -1) * returns

ts_delay( pcr_oi_60,1) * returns

divide( call_breakeven_10, put_breakeven_10 )

ts_mean( divide( call_breakeven_30, put_breakeven_30 ),10)

group_zscore( volume, pv13_revere_key_sector )

multiply( group_zscore(returns, sector), volume )

if_else( adv20 < 100000, 1, 0 ) * returns

add( zscore( adv20 ), zscore( fscore_surface ) )

multiply( ts_delta(close,5), ts_std_dev(returns,60) )

winsorize(group_scale(returns, sector))

divide( market_cap, ts_mean(market_cap,90) )

scale( divide(returns, market_cap), 1,0 )

group_backfill(returns, pv13_revere_company,30)

add( returns, multiply( beta_last_30_days_spy, 0.05 ) )

multiply( group_zscore(fscore_surface, pv13_revere_sector), group_zscore(returns, pv13_revere_sector) )

if_else( ts_mean(returns,10) > 0, 1, -1 ) * snt_value

add( normalize( returns ), normalize( group_zscore(returns, pv13_revere_company) ) )

multiply( adv20, ts_delta(volume,5) )

ts_corr( close, adv20,30 )

add( ts_delay(close,5), multiply( adv20, 0.001 ) )

scale( snt_value, 1, 0 )

multiply( snt_value, 10 )

if_else( snt_value > 0.6, zscore(returns), 0 )

divide( nws12_prez_02l, close )

ts_delay( nws12_allz_result1,1) * returns

group_mean( fscore_surface, sector )

divide( group_mean(eps_estimate, pv13_revere_company), group_mean(earnings_actual, pv13_revere_company) )

add( normalize( fscore_surface ), normalize( fscore_momentum ) )

multiply( fscore_surface, ts_delay(returns,5) )

ts_corr( fscore_surface, close,30 )

add( ts_delay(returns,1), ts_delay(returns,2) )

multiply( snt_value, ts_delay(returns,5) )

add( ts_delay(snt_value,1), ts_delay(snt_value,2) )

scale( group_zscore(returns, sector), 1, 0 )

if_else( snt_value > 0.5, -ts_delta(close,5), ts_delta(close,5) )

ts_mean( divide( group_mean(eps_estimate, pv13_revere_company), group_mean(earnings_actual, pv13_revere_company) ),20)

add( normalize( bffl_surface ), normalize( fscore_momentum ) )

multiply( group_zscore(returns, pv13_revere_company), multiplier( adv20, 0.01 ) )

scale( snt_social_volume, 1, 0 )

divide( call_breakeven_60, put_breakeven_60 )

ts_scale( divide(returns, adv20), 30,1 )

if_else( group_zscore(returns, sector) < 0.2, 1, 0 )