group_mean(if_else(ts_rank(volume, 30) > 0.7, ts_delta(close, 10), ts_delta(close, 30)), 1, industry)

multiply(ts_corr(returns, ts_delay(returns, 5), 20), group_mean(ts_delta(close, 5), 1, sector))

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

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

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

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

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

group_mean(ts_decay_linear(returns, 10), 1, bucket(ts_rank(volume, 30), range="0,3,0.4"))

multiply(ts_corr(group_mean(returns, 1, sector), returns, 30), ts_zscore(close, 60))

if_else(bucket(rank(volume), range="0,3,0.4") == 0, ts_delta(close, 10), ts_delta(close, 30))

multiply(ts_delta(close, 5), reverse(ts_rank(ts_delta(volume, 5), 10)))

group_mean(if_else(ts_mean(returns, 20) > 0, ts_delta(close, 10), reverse(ts_delta(close, 10))), 1, industry)

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

multiply(ts_rank(ts_delta(close, 5), 30), group_rank(volume, sector))

group_mean(ts_corr(returns, ts_mean(volume, 5), 20), 1, bucket(rank(close), range="0,3,0.4"))

if_else(ts_rank(ts_mean(returns, 60), 120) > 0.5, ts_delta(close, 10), ts_delta(close, 30))

multiply(group_zscore(ts_delta(close, 5), industry), ts_rank(volume, 20))

group_mean(ts_delta(close, 10) / ts_std_dev(returns, 20), 1, sector)

multiply(ts_regression(close, ts_step(1), 20, 0, 1), if_else(rank(volume) > 0.8, 1, 0.5))

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

multiply(group_rank(ts_delta(close, 5), industry), reverse(ts_rank(ts_delta(volume, 5), 10)))

group_mean(if_else(ts_std_dev(returns, 10) > ts_mean(ts_std_dev(returns, 10), 30), ts_delta(close, 5), ts_delta(close, 20)), 1, industry)

multiply(ts_corr(ts_delta(close, 5), ts_delta(volume, 5), 20), group_mean(returns, 1, sector))

if_else(ts_rank(ts_mean(volume, 20), 60) > 0.7, ts_delta(close, 10), ts_mean(returns, 20))

group_mean(ts_zscore(ts_delta(close, 20), 30), 1, bucket(rank(volume), range="0,3,0.4"))

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

ts_delta(close, 5) / ts_std_dev(returns, if_else(ts_rank(volume, 30) > 0.7, 10, 30))

multiply(group_mean(ts_regression(close, ts_step(1), 20, 0, 1), 1, industry), ts_rank(returns, 10))

if_else(bucket(ts_rank(volume, 30), range="0,3,0.4") == 0, ts_delta(close, 5), ts_delta(close, 20))

group_mean(multiply(ts_delta(close, 10), ts_zscore(volume, 20)), 1, sector)

multiply(ts_rank(ts_decay_linear(returns, 5), 20), group_zscore(close, industry))

ts_mean(returns, if_else(ts_std_dev(returns, 20) > 0.015, 5, 20))

group_mean(if_else(ts_delta(close, 1) > 0, ts_delta(close, 10), reverse(ts_delta(close, 10))), 1, bucket(rank(volume), range="0,3,0.4"))

multiply(ts_corr(ts_mean(returns, 5), ts_mean(volume, 5), 30), ts_delta(close, 10))

if_else(ts_rank(ts_std_dev(returns, 30), 60) > 0.6, ts_delta(close, 5), ts_regression(close, ts_step(1), 30, 0, 1))

group_mean(ts_delta(close, 20) * ts_rank(volume, 20), 1, industry)

multiply(reverse(ts_rank(ts_delta(volume, 1), 10)), group_mean(ts_delta(close, 5), 1, sector))

ts_delta(close, if_else(ts_mean(returns, 20) > 0, 10, 30))

group_mean(ts_zscore(ts_delta(close, 5), 20), 1, bucket(ts_rank(volume, 30), range="0,3,0.4"))

multiply(ts_regression(close, ts_step(1), 10, 0, 1), if_else(rank(volume) > 0.9, 2, 1))

if_else(ts_rank(ts_mean(volume, 30), 90) > 0.8, ts_delta(close, 5), ts_mean(returns, 30))

group_mean(multiply(ts_delta(close, 10), reverse(ts_rank(volume, 20))), 1, industry)

ts_corr(ts_delta(close, 5), ts_delta(volume, 5), 10) / ts_std_dev(returns, 20)

multiply(group_rank(ts_mean(returns, 20), sector), ts_zscore(ts_delta(close, 5), 30))

if_else(bucket(rank(ts_delta(volume, 1)), range="0,3,0.4") == 0, ts_delta(close, 10), ts_delta(close, 30))

group_mean(ts_delta(close, 5) / ts_mean(abs(returns), 20), 1, sector)

multiply(ts_rank(ts_decay_linear(returns, 10), 30), group_mean(volume, 1, industry))

ts_mean(returns, if_else(ts_rank(ts_std_dev(returns, 10), 30) > 0.7, 5, 20))

group_mean(if_else(ts_delta(volume, 1) > 0, ts_delta(close, 10), ts_delta(close, 20)), 1, bucket(rank(close), range="0,3,0.4"))

multiply(ts_corr(group_mean(ts_delta(close, 1), 1, sector), returns, 20), ts_regression(close, ts_step(1), 20, 0, 1))

if_else(ts_rank(ts_mean(returns, 30), 60) > 0.5, ts_delta(close, 10), reverse(ts_delta(close, 10)))

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

multiply(reverse(ts_rank(volume / ts_delay(volume, 1), 10)), ts_delta(close, 10))

ts_delta(close, 5) * if_else(ts_rank(volume, 30) > 0.7, 1.5, 1)

group_mean(multiply(ts_regression(close, ts_step(1), 30, 0, 1), ts_rank(volume, 20)), 1, sector)

if_else(ts_std_dev(returns, 20) > ts_mean(ts_std_dev(returns, 20), 60), ts_delta(close, 5), ts_mean(returns, 20))

multiply(group_zscore(ts_delta(close, 10), industry), reverse(ts_rank(ts_delta(volume, 5), 15)))

ts_mean(returns, if_else(bucket(rank(volume), range="0,3,0.4") == 0, 10, 30))

group_mean(ts_delta(close, 15) / ts_std_dev(returns, 30), 1, bucket(rank(volume), range="0,3,0.4"))

multiply(ts_corr(ts_mean(returns, 10), ts_mean(volume, 10), 20), group_rank(close, sector))

if_else(ts_rank(ts_delta(volume, 1), 30) > 0.8, ts_delta(close, 5), ts_delta(close, 20))

group_mean(if_else(ts_mean(returns, 10) > 0, ts_delta(close, 10), ts_delta(close, 30)), 1, industry)

multiply(ts_rank(ts_delta(close, 5), 20), group_zscore(volume, sector))

ts_delta(close, if_else(ts_rank(ts_std_dev(returns, 10), 30) > 0.6, 5, 20))

group_mean(ts_zscore(ts_delta(close, 10), 25), 1, bucket(ts_rank(volume, 20), range="0,3,0.4"))

multiply(reverse(ts_rank(ts_mean(volume, 5), 10)), group_mean(ts_delta(close, 5), 1, industry))

if_else(ts_rank(ts_mean(returns, 20), 40) > 0.5, ts_delta(close, 10), reverse(ts_delta(close, 10)))

multiply(ts_corr(returns, group_mean(returns, 1, sector), 30), ts_regression(close, ts_step(1), 25, 0, 1))

group_mean(ts_delta(close, 20) * if_else(rank(volume) > 0.8, 1.2, 0.8), 1, sector)

ts_mean(returns, if_else(ts_std_dev(returns, 15) > 0.02, 5, 25))

multiply(group_rank(ts_mean(returns, 15), industry), reverse(ts_rank(volume / ts_mean(volume, 30), 20)))

if_else(bucket(ts_rank(ts_delta(volume, 1), 20), range="0,3,0.4") == 0, ts_delta(close, 10), ts_mean(returns, 20))

group_mean(ts_delta(close, 10) / ts_mean(abs(returns), 30), 1, bucket(rank(close), range="0,3,0.4"))

multiply(ts_rank(ts_decay_linear(returns, 8), 25), group_mean(ts_zscore(volume, 20), 1, industry))

ts_delta(close, 5) * ts_rank(volume, 10) / ts_std_dev(returns, 20)

group_mean(if_else(ts_delta(volume, 1) > ts_mean(ts_delta(volume, 1), 10), ts_delta(close, 5), ts_delta(close, 15)), 1, sector)

multiply(ts_corr(ts_delta(close, 3), ts_delta(volume, 3), 15), group_zscore(returns, industry))

if_else(ts_rank(ts_std_dev(returns, 25), 50) > 0.7, ts_delta(close, 5), ts_regression(close, ts_step(1), 30, 0, 1))

group_mean(ts_zscore(ts_delta(close, 12), 24), 1, bucket(rank(volume), range="0,3,0.4"))

multiply(reverse(ts_rank(ts_delta(volume, 2), 12)), ts_delta(close, 12))

ts_mean(returns, if_else(ts_rank(volume, 30) > 0.9, 8, 22))

group_mean(multiply(ts_regression(close, ts_step(1), 18, 0, 1), ts_rank(ts_delta(volume, 1), 15)), 1, industry)

if_else(ts_rank(ts_mean(returns, 18), 36) > 0.5, ts_delta(close, 8), ts_delta(close, 22))

multiply(ts_corr(group_mean(returns, 1, sector), ts_delay(returns, 1), 20), group_rank(ts_delta(close, 5), industry))

group_mean(ts_delta(close, 15) / if_else(ts_std_dev(returns, 20) > 0.018, ts_std_dev(returns, 20), 0.01), 1, sector)

multiply(ts_rank(ts_delta(close, 6), 18), reverse(group_zscore(volume, industry)))

ts_delta(close, if_else(bucket(rank(ts_mean(volume, 20)), range="0,3,0.4") == 0, 6, 18))

group_mean(if_else(ts_mean(returns, 15) > group_mean(ts_mean(returns, 15), 1, industry), ts_delta(close, 10), ts_delta(close, 20)), 1, sector)

multiply(ts_decay_linear(returns, 10), group_mean(ts_rank(volume, 20), 1, industry))

if_else(ts_rank(ts_std_dev(returns, 22), 44) > 0.65, ts_delta(close, 7), ts_mean(returns, 22))

group_mean(ts_zscore(ts_delta(close, 8), 16), 1, bucket(ts_rank(returns, 20), range="0,3,0.4"))

multiply(reverse(ts_rank(volume / ts_delay(volume, 5), 15)), group_mean(ts_regression(close, ts_step(1), 20, 0, 1), 1, sector))

ts_delta(close, 10) * if_else(ts_rank(ts_delta(volume, 5), 30) > 0.8, 1.3, 0.7)

group_mean(multiply(ts_corr(returns, ts_mean(volume, 10), 25), ts_delta(close, 9)), 1, industry)

if_else(ts_rank(ts_mean(volume, 25), 50) > 0.75, ts_delta(close, 6), ts_delta(close, 18))

multiply(group_rank(ts_zscore(close, 30), sector), ts_delta(close, 11))

group_mean(ts_delta(close, 14) / ts_std_dev(returns, 28), 1, bucket(rank(volume), range="0,3,0.4"))

multiply(ts_rank(ts_mean(returns, 12), 24), reverse(group_mean(ts_rank(volume, 15), 1, industry)))

ts_mean(returns, if_else(ts_std_dev(returns, 18) > ts_mean(ts_std_dev(returns, 18), 36), 7, 21))

group_mean(if_else(ts_delta(close, 1) > ts_mean(ts_delta(close, 1), 10), ts_delta(close, 8), reverse(ts_delta(close, 8))), 1, sector)

multiply(ts_corr(ts_delta(close, 4), ts_delta(volume, 4), 18), group_zscore(ts_delta(close, 4), industry))

if_else(bucket(ts_rank(ts_std_dev(returns, 15), 30), range="0,3,0.4") == 0, ts_delta(close, 5), ts_delta(close, 25))

group_mean(ts_delta(close, 16) * ts_rank(ts_delta(volume, 2), 20), 1, industry)

multiply(reverse(ts_rank(ts_mean(volume, 8), 16)), ts_regression(close, ts_step(1), 22, 0, 1))

ts_delta(close, if_else(ts_rank(returns, 30) > 0.7, 9, 27))

group_mean(ts_zscore(ts_delta(close, 7), 14), 1, bucket(rank(ts_delta(volume, 1)), range="0,3,0.4"))

multiply(ts_mean(returns, 15), if_else(group_rank(volume, sector) > 0.8, 1.5, 0.5))

if_else(ts_rank(ts_mean(returns, 28), 56) > 0.55, ts_delta(close, 10), reverse(ts_delta(close, 10)))

group_mean(multiply(ts_corr(ts_mean(returns, 8), group_mean(ts_mean(returns, 8), 1, sector), 20), ts_delta(close, 10)), 1, industry)

ts_delta(close, 5) / if_else(ts_rank(volume, 30) > 0.85, ts_std_dev(returns, 10), ts_std_dev(returns, 30))

multiply(group_zscore(ts_regression(close, ts_step(1), 25, 0, 1), sector), reverse(ts_rank(ts_delta(volume, 3), 18)))