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