private object Trie {
    private final case class MutableTrie[T](structure: scala.collection.mutable.Map[T, MutableTrie[T]], depth: Int, isLeaf: AtomicBoolean) {
      def toTrie: Trie[T] =
        Trie(
          structure = this.structure.map{ case (key, mutableTrie) => (key, mutableTrie.toTrie)}.toMap,
          depth = this.depth,
          isLeaf = this.isLeaf.get()
        )
    }

    private object MutableTrie {
      def empty[T]: MutableTrie[T]            = MutableTrie(structure = scala.collection.mutable.Map.empty[T, MutableTrie[T]], depth = 0, isLeaf = new AtomicBoolean(false))
      def next[T](depth: Int): MutableTrie[T] = MutableTrie(structure = scala.collection.mutable.Map.empty[T, MutableTrie[T]], depth = depth, isLeaf = new AtomicBoolean(false))
    }

    def apply[T](delimiters: Seq[Seq[T]]): Trie[T] = {
      var index                      = 0
      val outerIterator              = delimiters.iterator
      var root                       = MutableTrie.empty[T]

      while (outerIterator.hasNext) {
        val innerIterator = outerIterator.next().iterator
        var curNode = root
        index   = 0
        if (innerIterator.hasNext) {
          while (innerIterator.hasNext) {
            val elem     = innerIterator.next()
            curNode = curNode.structure.get(elem) match {
              case Some(nextNode) => nextNode
              case None           => {
                var nextNode = MutableTrie.next[T](depth = index + 1)
                curNode.structure += (elem -> nextNode)
                nextNode
              }
            }
            index += 1
          }
          curNode.isLeaf.set(true)
        }
      }
      return root.toTrie
    }
  }