add(multiply(group_zscore(divide(ts_sum(volume,5),ts_mean(volume,20)), industry), reverse(ts_scale(ts_corr(ts_delta(close,5),ts_delay(ts_delta(close,5),1),20),20,constant=-0.5))), multiply(0.7, ts_delta(close,20), if_else(ts_rank(ts_std_dev(returns,60),120) > 0.7, 1, divide(0.5, ts_std_dev(returns,60)))))

group_neutralize(multiply(divide(ts_delta(close,10), ts_std_dev(returns,10)), ts_rank(ts_delta(close,20),60), if_else(ts_rank(volume,120) > 0.8, 0.8, 1.2)), sector)

multiply(ts_corr(group_zscore(ts_delta(close,5), sector), group_zscore(ts_delay(ts_delta(close,5),5), sector), 30), if_else(bucket(rank(volume), range="0,3,0.4") == 0, ts_delta(close,5), ts_delta(close,10)))

add(multiply(reverse(ts_rank(divide(volume, ts_mean(volume,20)), 10)), ts_delta(close,20)), multiply(0.3, ts_zscore(ts_corr(ts_delay(close,1), close, 20), 60)))

group_scale(multiply(ts_scale(ts_delta(close,20),20), ts_rank(ts_std_dev(returns,5),20), if_else(ts_rank(ts_mean(abs(returns),10),30) > 0.7, 1, -1)), industry)

if_else(ts_std_dev(returns,20) > 0.02, multiply(ts_delta(close,5), divide(1, ts_std_dev(returns,5))), multiply(ts_delta(close,30), divide(1, ts_std_dev(returns,30))))

multiply(ts_corr(ts_delay(ts_delta(close,1),1), ts_delta(close,1), 10), group_zscore(ts_sum(volume,5), industry), ts_rank(ts_delta(close,10),30))

add(group_neutralize(ts_regression(close, ts_step(1), 30, 0, 1), sector), multiply(0.5, ts_zscore(divide(volume, ts_mean(volume,60)), 20)))

multiply(if_else(ts_rank(volume,120) > 0.8, ts_delta(close,5), ts_delta(close,20)), ts_rank(ts_corr(close, volume, 10), 30), reverse(ts_scale(ts_sum(returns,5),5)))

group_zscore(multiply(ts_delta(close,20), divide(1, ts_std_dev(returns,20)), ts_rank(ts_mean(volume,10),60)), industry)

multiply(ts_corr(ts_delay(group_mean(returns, 1, industry), 1), group_mean(returns, 1, industry), 20), ts_delta(close, 10))

group_neutralize(multiply(ts_rank(ts_delta(close, 20), 60), bucket(rank(volume), range="0,3,0.4")), industry)

if_else(ts_std_dev(returns, 20) > 0.02, ts_delta(close, 5), ts_delta(close, 20))

multiply(reverse(ts_rank(divide(volume, ts_mean(volume, 20)), 10)), ts_delta(close, 20))

group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, bucket(rank(volume), range="0,3,0.4"))

ts_corr(ts_delay(ts_delta(close, 5), 1), ts_delta(close, 5), 10)

group_zscore(ts_delta(close, 20), industry)

multiply(ts_std_dev(returns, 60), ts_rank(ts_delta(close, 20), 60))

ts_regression(ts_delta(close, 20), ts_step(1), 30, 0, 1)

group_rank(ts_delta(close, 20), industry)

ts_decay_linear(ts_delta(close, 20), 30)

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

group_scale(ts_rank(ts_delta(close, 20), 60), industry)

ts_av_diff(ts_delta(close, 20), 60)

if_else(ts_rank(ts_std_dev(returns, 60), 120) > 0.7, ts_delta(close, 5), ts_delta(close, 20))

ts_corr(group_mean(ts_delta(close, 10), 1, industry), group_mean(ts_delta(close, 10), 1, industry), 30)

ts_mean(ts_delta(close, 20), 20)

ts_scale(ts_delta(close, 20), 20)

ts_quantile(ts_delta(close, 20), 60)

winsorize(ts_delta(close, 20), std=4)

hump(ts_delta(close, 20), hump=0.01)

ts_count_nans(ts_delta(close, 20), 60)

ts_backfill(ts_delta(close, 20), lookback=30, k=1)

ts_product(ts_delta(close, 20), 20)

ts_sum(ts_delta(close, 20), 20)

ts_arg_max(ts_delta(close, 20), 60)

ts_arg_min(ts_delta(close, 20), 60)

ts_covariance(ts_delta(close, 20), ts_delta(close, 20), 30)

ts_decay_linear(ts_zscore(volume, 20), 30)

group_backfill(ts_delta(close, 20), industry, 30, std=4.0)

ts_rank(ts_zscore(volume, 20), 60)

normalize(ts_delta(close, 20), useStd=true, limit=0.0)

quantile(ts_delta(close, 20), driver="gaussian", sigma=1.0)

rank(ts_delta(close, 20), rate=2)

scale(ts_delta(close, 20), scale=1, longscale=1, shortscale=1)

zscore(ts_delta(close, 20))

vec_avg(ts_delta(close, 20))

vec_sum(ts_delta(close, 20))

bucket(rank(ts_delta(close, 20)), range="0,3,0.4")

trade_when(ts_delta(close, 20), ts_std_dev(returns, 20) > 0.02, ts_delta(close, 5))

multiply(ts_corr(ts_delay(ts_delta(close, 5), 1), ts_delta(close, 5), 10), ts_delta(close, 20))

group_mean(ts_delta(close, 20), 1, industry)

group_neutralize(ts_delta(close, 20), industry)

group_rank(ts_delta(close, 20), industry)

group_scale(ts_delta(close, 20), industry)

group_zscore(ts_delta(close, 20), industry)

ts_regression(ts_delta(close, 20), ts_step(1), 30, 0, 1)

ts_std_dev(ts_delta(close, 20), 20)

ts_mean(ts_delta(close, 20), 20)

ts_sum(ts_delta(close, 20), 20)

ts_product(ts_delta(close, 20), 20)

ts_corr(ts_delta(close, 20), ts_delta(close, 20), 30)

ts_covariance(ts_delta(close, 20), ts_delta(close, 20), 30)

ts_decay_linear(ts_delta(close, 20), 30)

ts_delay(ts_delta(close, 20), 1)

ts_delta(ts_delta(close, 5), 5)

ts_av_diff(ts_delta(close, 20), 60)

ts_scale(ts_delta(close, 20), 20)

ts_quantile(ts_delta(close, 20), 60)

ts_rank(ts_delta(close, 20), 60)

ts_zscore(ts_delta(close, 20), 20)

winsorize(ts_delta(close, 20), std=4)

hump(ts_delta(close, 20), hump=0.01)

ts_backfill(ts_delta(close, 20), lookback=30, k=1)

ts_count_nans(ts_delta(close, 20), 60)

ts_arg_max(ts_delta(close, 20), 60)

ts_arg_min(ts_delta(close, 20), 60)

ts_regression(ts_delta(close, 20), ts_step(1), 30, 0, 1)

group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, industry)

group_neutralize(ts_regression(close, ts_step(1), 30, 0, 1), industry)

group_rank(ts_regression(close, ts_step(1), 30, 0, 1), industry)

group_scale(ts_regression(close, ts_step(1), 30, 0, 1), industry)

group_zscore(ts_regression(close, ts_step(1), 30, 0, 1), industry)

ts_corr(ts_delay(group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, industry), 1), group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, industry), 20)

multiply(ts_corr(ts_delay(group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, industry), 1), group_mean(ts_regression(close, ts_step(1), 30, 0, 1), 1, industry), 20), ts_regression(close, ts_step(1), 30, 0, 1))

if_else(ts_std_dev(returns, 20) > 0.02, ts_regression(close, ts_step(1), 10, 0, 1), ts_regression(close, ts_step(1), 30, 0, 1))

multiply(reverse(ts_rank(divide(volume, ts_mean(volume, 20)), 10)), ts_regression(close, ts_step(1), 30, 0, 1))

ts_mean(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_sum(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_product(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_std_dev(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_zscore(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_rank(ts_regression(close, ts_step(1), 30, 0, 1), 60)

ts_scale(ts_regression(close, ts_step(1), 30, 0, 1), 20)

ts_quantile(ts_regression(close, ts_step(1), 30, 0, 1), 60)

ts_corr(ts_regression(close, ts_step(1), 30, 0, 1), ts_regression(close, ts_step(1), 30, 0, 1), 30)

ts_covariance(ts_regression(close, ts_step(1), 30, 0, 1), ts_regression(close, ts_step(1), 30, 0, 1), 30)

ts_decay_linear(ts_regression(close, ts_step(1), 30, 0, 1), 30)

ts_delay(ts_regression(close, ts_step(1), 30, 0, 1), 1)

ts_delta(ts_regression(close, ts_step(1), 30, 0, 1), 5)

ts_av_diff(ts_regression(close, ts_step(1), 30, 0, 1), 60)

ts_backfill(ts_regression(close, ts_step(1), 30, 0, 1), lookback=30, k=1)

ts_count_nans(ts_regression(close, ts_step(1), 30, 0, 1), 60)

ts_arg_max(ts_regression(close, ts_step(1), 30, 0, 1), 60)

ts_arg_min(ts_regression(close, ts_step(1), 30, 0, 1), 60)

winsorize(ts_regression(close, ts_step(1), 30, 0, 1), std=4)

hump(ts_regression(close, ts_step(1), 30, 0, 1), hump=0.01)

normalize(ts_regression(close, ts_step(1), 30, 0, 1), useStd=true, limit=0.0)

quantile(ts_regression(close, ts_step(1), 30, 0, 1), driver="gaussian", sigma=1.0)

rank(ts_regression(close, ts_step(1), 30, 0, 1), rate=2)

scale(ts_regression(close, ts_step(1), 30, 0, 1), scale=1, longscale=1, shortscale=1)

zscore(ts_regression(close, ts_step(1), 30, 0, 1))

vec_avg(ts_regression(close, ts_step(1), 30, 0, 1))

vec_sum(ts_regression(close, ts_step(1), 30, 0, 1))

bucket(rank(ts_regression(close, ts_step(1), 30, 0, 1)), range="0,3,0.4")

trade_when(ts_regression(close, ts_step(1), 30, 0, 1), ts_std_dev(returns, 20) > 0.02, ts_regression(close, ts_step(1), 10, 0, 1))


group_neutralize(multiply(ts_corr(ts_delta(close, 10), ts_delta(close, 60), 30), ts_zscore(volume, 20)), sector)

multiply(if_else(ts_rank(divide(volume, ts_mean(volume, 20)), 60) > 0.8, ts_delta(close, 5), divide(ts_delta(close, 10), ts_mean(abs(returns), 10))), group_rank(ts_corr(group_mean(returns, 1, industry), returns, 20), sector))

multiply(ts_rank(divide(volume, ts_mean(volume, 20)), 30), group_neutralize(ts_corr(ts_delay(group_mean(returns, 1, industry), 3), returns, 20), industry))

multiply(ts_rank(ts_std_dev(returns, 20), 60), if_else(ts_corr(ts_mean(close, 5), ts_mean(close, 60), 30) > 0.7, ts_delta(close, 10), reverse(ts_delta(close, 10))))

multiply(group_neutralize(divide(ts_delta(close, 10), ts_std_dev(returns, 20)), industry), ts_rank(ts_zscore(volume, 20), 60))

if_else(ts_rank(ts_mean(divide(volume, ts_mean(volume, 20)), 30), 120) > 0.7, ts_corr(ts_delay(group_mean(returns, 1, sector), 2), returns, 20), reverse(ts_delta(close, 20)))

group_neutralize(multiply(ts_regression(close, ts_step(1), 30, 0, 1), divide(volume, ts_mean(volume, 60))), subindustry)

multiply(ts_rank(ts_corr(close, ts_mean(close, 60), 20), 60), divide(group_neutralize(ts_delta(close, 20), industry), ts_std_dev(returns, 20)))

multiply(if_else(rank(volume) > 0.7, group_mean(ts_delta(close, 10), 1, bucket(rank(volume), range="0,3,0.4")), ts_delta(close, 5)), ts_zscore(volume, 30))

multiply(group_neutralize(ts_corr(ts_delta(close, 20), ts_delay(group_mean(returns, 1, industry), 1), 30), industry), ts_rank(divide(volume, ts_mean(volume, 10)), 60))

if_else(ts_rank(ts_std_dev(returns, 20), 120) > 0.8, ts_rank(ts_delta(close, 5), 30), divide(ts_delta(close, 30), ts_mean(abs(returns), 30)))

group_neutralize(multiply(ts_zscore(volume, 20), sign(ts_corr(ts_mean(close, 5), ts_mean(close, 20), 20))), sector)

multiply(ts_rank(ts_corrrank(close, ts_mean(close, 60), 30), 60), reverse(divide(volume, ts_mean(volume, 10))))

divide(multiply(ts_regression(close, ts_step(1), 30, 0, 1), ts_zscore(volume, 20)), ts_std_dev(returns, 60))

group_neutralize(multiply(ts_corr(group_mean(returns, 1, industry), returns, 20), if_else(ts_rank(volume, 30) > 0.8, ts_delta(close, 5), ts_delta(close, 20))), industry)

multiply(ts_rank(divide(volume, ts_mean(volume, 60)), 60), group_rank(ts_delta(close, 20), industry))

multiply(if_else(ts_corr(ts_mean(close, 5), ts_mean(close, 30), 20) > 0.5, 1, -1), divide(ts_delta(close, 10), ts_std_dev(returns, 20)))

group_neutralize(multiply(ts_rank(ts_zscore(volume, 20), 60), ts_delta(close, 10)), sector)

multiply(ts_corr(ts_delta(close, 10), ts_delay(ts_delta(close, 10), 5), 60), rank(volume))

multiply(if_else(ts_rank(ts_std_dev(returns, 30), 60) > 0.7, ts_delta(close, 10), ts_delta(close, 60)), group_zscore(volume, subindustry))

multiply(ts_rank(group_mean(ts_delta(close, 10), 1, sector), 30), ts_corr(close, ts_delay(close, 30), 60))

group_neutralize(multiply(ts_rank(ts_mean(divide(volume, ts_mean(volume, 20)), 30), 60), ts_regression(close, ts_step(1), 20, 0, 1)), industry)

multiply(reverse(ts_rank(divide(volume, ts_mean(volume, 20)), 30)), divide(ts_delta(close, 10), group_mean(abs(ts_delta(close, 10)), 1, industry)))

ts_delta(close, 20) * bucket(rank(volume), range="0,3,0.4")  

group_mean(ts_delta(close, 10), 1, industry) * ts_rank(ts_std_dev(returns, 20), 60)  

ts_corr(group_mean(returns, 1, industry_A), group_mean(returns, 1, industry_B), 30) * ts_delta(close, 10)  

multiply(reverse(ts_rank(divide(volume, ts_mean(volume, 20)), 10)), ts_delta(close, 20))  

ts_regression(close, ts_step(1), 60, 0, 1) * group_zscore(ts_delta(close, 5), industry)  

hump(ts_delta(ts_delta(close, 5), 5), hump=0.01) * group_neutralize(ts_rank(volume, 20), industry)  

winsorize(ts_delta(close, 10) / ts_std_dev(returns, 10), std=4) * bucket(rank(ts_std_dev(returns, 60)), range="0,5,0.25")  

if_else(ts_rank(ts_std_dev(returns, 60), 120) > 0.7, ts_delta(close, 5), ts_delta(close, 60)) * group_scale(close, industry)  

ts_delay(group_mean(returns, 1, sector), 10) * ts_zscore(volume, 20)  

ts_delta(group_mean(close, 1, subindustry), 5) * ts_corr(close, ts_mean(close, 60), 30)  

hump(multiply(ts_delta(close, 20), group_rank(volume, industry)), hump=0.01) * ts_rank(ts_std_dev(returns, 20), 60)  

bucket(ts_rank(ts_delta(close, 10), 30), range="0,4,0.25") * group_neutralize(ts_regression(close, ts_step(1), 20, 0, 1), sector)  

ts_product(ts_delta(close, 5), 5) * group_zscore(divide(volume, adv20), subindustry)  

ts_mean(ts_delta(close, 20), 30) * if_else(rank(volume) > 0.8, 1, -1)  

winsorize(group_mean(ts_delta(close, 10), 1, industry), std=3) * ts_rank(ts_std_dev(returns, 60), 120)  

ts_corr(ts_delay(close, 10), group_mean(close, 1, sector), 30) * group_zscore(ts_delta(close, 5), subindustry)  

hump(group_mean(ts_delta(close, 20), 1, industry) - ts_delta(close, 20), hump=0.01) * ts_rank(volume, 20)  

bucket(group_rank(returns, sector), range="0,5,0.2") * multiply(ts_delta(close, 10), ts_std_dev(returns, 10))  

ts_delay(group_mean(returns, 1, industry_A), 5) * ts_corr(group_mean(returns, 1, industry_B), close, 20)  

hump(ts_rank(ts_delta(close, 5), 10) * group_scale(ts_std_dev(returns, 60), industry), hump=0.01) * ts_mean(volume, 20)  

group_zscore(ts_delta(close, 20), sector) * if_else(ts_std_dev(returns, 20) > 0.02, ts_delta(close, 5), ts_delta(close, 60))  

ts_regression(group_mean(close, 1, subindustry), ts_step(1), 60, 0, 1) * bucket(rank(ts_std_dev(returns, 20)), range="0,4,1")  

ts_delta(group_mean(close, 1, sector), 10) * winsorize(ts_rank(volume, 30), std=3)  

multiply(ts_corr(close, ts_mean(close, 60), 30), ts_delta(close, 20)) * group_neutralize(ts_delta(close, 5), industry)  

hump(group_mean(ts_delta(close, 5), 1, industry) * ts_rank(ts_std_dev(returns, 20), 60), hump=0.01) * bucket(rank(volume), range="0,3,0.3")  

ts_delay(group_mean(returns, 1, industry), 5) * group_scale(ts_delta(close, 10), subindustry)  

ts_delta(ts_regression(close, ts_step(1), 30, 0, 1), 5) * bucket(rank(ts_std_dev(returns, 60)), range="0,5,1")  

group_mean(ts_delta(close, 10), 1, sector) * if_else(ts_rank(ts_std_dev(returns, 60), 120) > 0.8, ts_delta(close, 5), ts_delta(close, 20))  

hump(multiply(ts_delta(close, 20), ts_rank(volume, 30)), hump=0.01) * group_rank(ts_std_dev(returns, 20), industry)  

ts_corr(ts_delay(group_mean(returns, 1, industry_A), 5), group_mean(returns, 1, industry_B), 30) * ts_delta(close, 10)  

bucket(group_rank(ts_delta(close, 20), subindustry), range="0,5,0.25") * group_neutralize(ts_zscore(volume, 20), sector)  

ts_delay(group_mean(close, 1, sector), 10) * multiply(ts_delta(close, 5), ts_std_dev(returns, 5))  

group_neutralize(hump(ts_delta(close, 30), hump=0.01), industry) * bucket(rank(ts_mean(volume, 60)), range="0,4,0.25")  

ts_corr(group_mean(returns, 1, industry), close, 20) * if_else(ts_std_dev(returns, 20) > 0.03, ts_delta(close, 5), ts_delta(close, 20))  

winsorize(hump(ts_delta(close, 10), hump=0.01) * ts_rank(volume, 30), std=4) * group_scale(ts_std_dev(returns, 60), subindustry)  

ts_delay(group_mean(close, 1, subindustry), 5) * ts_corr(close, ts_mean(close, 60), 30)  

bucket(group_zscore(ts_delta(close, 10), sector), range="0,5,0.2") * multiply(reverse(ts_rank(volume, 20)), ts_delta(close, 20))  

ts_regression(group_mean(close, 1, industry), ts_step(1), 60, 0, 1) * if_else(ts_rank(ts_std_dev(returns, 60), 120) > 0.7, ts_delta(close, 5), ts_delta(close, 60))  

group_mean(winsorize(ts_delta(close, 20), std=3), 1, sector) * ts_rank(ts_std_dev(returns, 20), 60)  

ts_corr(group_mean(returns, 1, industry_A), group_mean(returns, 1, industry_B), 30) * ts_delta(close, 10)  

hump(group_mean(ts_delta(close, 5), 1, industry) * ts_rank(ts_std_dev(returns, 60), 120), hump=0.01) * bucket(rank(volume), range="0,3,0.4")