dune

(env
 (dev
  (flags (:standard -w -9-27-26-32))))

(executable
  (name anagrams)
  (modules anagrams)
  (promote (until-clean))
  (libraries trie mset))

(library
 (name arrays)
 (modules arrays))
(test
 (name test_arrays)
 (modules test_arrays)
 (libraries arrays))

(library
 (name bitset)
 (modules bitset))
(test
 (name test_bitset)
 (modules test_bitset)
 (libraries bitset))

(executable
 (name brainfuck)
 (promote (until-clean))
 (modules brainfuck))

(library
 (name braun)
 (modules braun))
(test
 (name test_braun)
 (modules test_braun)
 (libraries braun))

(executable
 (name burr)
 (promote (until-clean))
 (modules burr))

(executable
 (name comb)
 (promote (until-clean))
 (modules comb))

(library
 (name deque)
 (modules deque))
(test
 (name test_deque)
 (modules test_deque)
 (libraries deque))

(executable
 (name dice_puzzle)
 (promote (until-clean))
 (modules dice_puzzle)
 (libraries bag))

(library
 (name dill)
 (modules dill))
(test
 (name test_dill)
 (modules test_dill)
 (libraries dill))

(library
 (name dlx)
 (modules dlx))
(library
 (name dlxm)
 (modules dlxm))

(executable
 (name dlx_queens)
 (promote (until-clean))
 (modules dlx_queens)
 (libraries dlx))

(library
 (name dyadic)
 (modules dyadic)
 (libraries zarith))
(test
 (name test_dyadic)
 (modules test_dyadic)
 (libraries dyadic))

(library
 (name fenwick)
 (modules fenwick))
(test
 (name test_fenwick)
 (modules test_fenwick)
 (libraries fenwick))

(library
 (name floyd)
 (modules floyd))
(test
 (name test_floyd)
 (modules test_floyd)
 (libraries floyd))

(library
 (name garsia_wachs)
 (modules garsia_wachs))

(library
 (name hashset)
 (modules hashset))
(test
 (name test_hashset)
 (modules test_hashset)
 (libraries time hashset))

(library
 (name hcpt)
 (modules hcpt))
(test
 (name test_hcpt)
 (modules test_hcpt)
 (libraries hcpt))

(library
 (name idd)
 (modules idd))
(test
 (name test_idd)
 (modules test_idd)
 (libraries idd))

(library
 (name itv)
 (modules itv))
(test
 (name test_itv)
 (modules test_itv)
 (libraries itv))

(executable
 (name jotto)
 (modules jotto))

(executable
 (name latticemult)
 (promote (until-clean))
 (modules latticemult))

(library
 (name LCA)
 (modules LCA)
 (libraries RMQ))
(test
 (name test_lca)
 (modules test_lca)
 (libraries LCA))

(library
 (name leftistheap)
 (modules leftistheap))

(library
 (name lral)
 (modules lral))
(test
 (name test_lral)
 (modules test_lral)
 (libraries lral))

(executable
 (name mastermind)
 (flags ())
 (promote (until-clean))
 (modules mastermind)
 (libraries curses unix))

(library
 (name matrix)
 (modules matrix))
(test
 (name test_matrix)
 (modules test_matrix)
 (libraries matrix))

(library
 (name mset)
 (modules mset))
(test
 (name test_mset)
 (modules test_mset)
 (libraries mset))

(executable
 (name nerdle)
 (flags ())
 (promote (until-clean))
 (modules nerdle))

(executable
 (name pal)
 (flags ())
 (promote (until-clean))
 (modules pal))

(library
 (name parray)
 (modules parray))
(test
 (name test_parray)
 (modules test_parray)
 (libraries parray))

(executable
 (name parse_arith)
 (promote (until-clean))
 (modules parse_arith))
(executable
 (name parse_arith_cont)
 (promote (until-clean))
 (modules parse_arith_cont))

(library
 (name permutation)
 (modules permutation)
 (libraries fenwick))
(test
 (name test_permutation)
 (modules test_permutation)
 (libraries permutation))

(library
 (name pmpq)
 (modules pmpq))
(test
 (name test_pmpq)
 (modules test_pmpq)
 (libraries pmpq))

(library
 (name pointer)
 (modules pointer))
(test
 (name test_pointer)
 (modules test_pointer)
 (libraries pointer))

(library
 (name prtree)
 (modules prtree))

(library
 (name puf)
 (modules puf)
 (libraries parray))
(test
 (name test_puf)
 (modules test_puf)
 (libraries parray puf))

(library
 (name radixsort)
 (modules radixsort))
(test
 (name test_radixsort)
 (modules test_radixsort)
 (libraries radixsort))

(library
 (name random_access_list)
 (modules random_access_list))

(executable
 (name re)
 (promote (until-clean))
 (modules re)
 (libraries time))

(library
 (name RMQ)
 (modules RMQ))
(test
 (name test_rmq)
 (modules test_rmq)
 (libraries RMQ))

(library
 (name rope)
 (modules rope))
(test
 (name test_rope)
 (modules test_rope)
 (libraries rope))

(executable
 (name rule110)
 (modules rule110))

(executable
 (name sieve)
 (modules sieve))

(executable
 (name sieve_seq)
 (modules sieve_seq)
 (libraries braun))

(library
 (name skew_heap)
 (modules skew_heap))

(executable
 (name snake)
 (promote (until-clean))
 (modules snake))

(executable
 (name soccer)
 (promote (until-clean))
 (modules soccer)
 (libraries permutation))

(library
 (name sparse)
 (modules sparse))
(test
 (name test_sparse)
 (modules test_sparse)
 (libraries arrays sparse))

(executable
 (name sudoku)
 (promote (until-clean))
 (modules sudoku)
 (libraries sparse))

(library
 (name suffix_tree)
 (modules suffix_tree))

(library
 (name tape)
 (modules tape))
(test
 (name test_tape)
 (modules test_tape)
 (libraries tape))

(library
 (name tbt)
 (modules tbt))
(test
 (name test_tbt)
 (modules test_tbt)
 (libraries tbt))

(library
 (name time)
 (modules time)
 (libraries unix))

(executable
 (name test_queue)
 (modules test_queue)
 (promote (until-clean))
 (libraries time))

(executable
 (name tetris)
 (flags ())
 (promote (until-clean))
 (modules tetris)
 (libraries curses unix))

(library
 (name tree)
 (modules tree))

(library
 (name trie)
 (modules trie))

(executable
 (name word5)
 (flags ())
 (promote (until-clean))
 (modules word5))

(executable
 (name wordle)
 (flags ())
 (promote (until-clean))
 (modules wordle))

(executable
 (name word_rect)
 (flags ())
 (promote (until-clean))
 (modules word_rect))