Не получается переделать рекурсивный алгоритм поиска всех путей в графе в итеративный

func (this *Graph) FindPath(from Word, to Word, visited Dict, current Path) {
    if from.Eq(to) {
        if len(current) > this.Max {
            this.Max = len(current)
            fmt.Println(current)
        }
 
        this.Pathes = append(this.Pathes, current)
        return
    }
 
    if visited.Index(from) != -1 {
        return
    }
 
    index := this.nodes.Index(from)
 
    if index == -1 {
        return
    }
 
    for r := 0; r < len(this.rules); r++ {
        index := from.Index(this.rules[r].Pat)
 
        if index == -1 {
            continue
        }
 
        vis := make(Dict, len(visited))
        copy(vis, visited)
        vis = append(vis, from)
 
        cur := make(Path, len(current))
        copy(cur, current)
        cur = append(cur, this.rules[r])
 
        this.FindPath(from.ApplyRule(this.rules[r]), to, vis, cur)
    }
}

func (this *Graph) FindPathes(from Word, to Word) {
    this.Pathes = make([]Path, 0)
    this.Max = 0
 
    nodes := stack.New()
    pathes := stack.New()
    visiteds := stack.New()
 
    nodes.Push(from)
    visiteds.Push(Dict{from})
    pathes.Push(make(Path, 0))
 
    for nodes.Len != 0 {
        curn := nodes.Pop().(Word)
        curp := pathes.Pop().(Path)
        curv := visiteds.Pop().(Dict)
 
        if curn.Eq(to) {
            if len(curp) > this.Max {
                this.Max = len(curp)
                fmt.Println(curp.ApplyVerbose(from))
            }
 
            this.Pathes = append(this.Pathes, curp)
            continue
        }
 
        for r := 0; r < len(this.rules); r++ {
            index := curn.Index(this.rules[r].Pat)
 
            if index == -1 {
                continue
            }
 
            newword := curn.ApplyRule(this.rules[r])
 
            if curv.Index(newword) != -1 {
                continue
            }
 
            newp := make(Path, len(curp))
            copy(newp, curp)
            newp = append(curp, this.rules[r])
 
            newv := make(Dict, len(curv))
            copy(newv, curv)
            newv = append(newv, newword)
 
            pathes.Push(newp)
            nodes.Push(newword)
            visiteds.Push(newv)
        }
    }
}