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)