function hackTAS(s) {
    console.time()
    // Joined by * so we can split later
    const lvlAs1D = s.join `*`.split(''),
          rowWidth = s[0].length + 1,
          swimDirections = [
        [[1],[-1],[rowWidth],[-rowWidth]],
        [[1, 2, 3],[-1,-2, -3],[rowWidth, 2 * rowWidth],[-rowWidth, -2 * rowWidth]]
    ],
          start = lvlAs1D.indexOf('S'),
          // Position, steps, flags, seen
          queue = [[start, 0, 0, ""]],
          visited = new Set()
    visited.add(`${start},0,""`)
    while (queue[0]) {
        let [pos,steps,flags,order] = queue.shift()
//        console.log(lvlAs1D[pos])
        //console.log(pos,order,flags)
        //console.log(map.join``.split('*'))
        if (lvlAs1D[pos] == 'E') {
            console.log(order)
            console.timeEnd()
            return steps
        }
        const [resetOrder, resetFlags] = [order, flags]
        // Do we move like fish?
        for (const direction of swimDirections[+((flags & 2) == 2)]) {
            // Reset so no carryover
            [order, flags] = [resetOrder, resetFlags]
            // Keep track of in loop
            let dkIndex = 0,
                fIndex = 0;
            // Loop on movement patterns
            for (const x of direction) {
                // Calculate next potential tile
                const nextTile = pos + x;
                // Check if valid number
                if (nextTile in lvlAs1D) {
                    // Break on wall or connector
                    if ('#*'.includes(d=lvlAs1D[nextTile])) break;
                    // Did we find D?
                    if (d == 'D' && !order.includes(`${d}(${nextTile})`)) {
                        // Set found flag and location
                        flags |= 16
                        dkIndex = nextTile
                        // Add to order
                        order += `${d}(${nextTile})`
                    }
                    if (d == 'F' && !order.includes(`${d}(${nextTile})`)) {
                        // Set found flag and location
                        flags |= 32
                        fIndex = nextTile
                        // Add to order
                        order += `${d}(${nextTile})`
                    }

                    // Do we have the fish?
                    if (flags & 2) {
                        // Do we run into C with fish?
                        if (d == 'C') {
                            // If so, take damage (lose fish), add to queue, and break
                            flags ^= 2 /*1*/
                            if (flags & 32) flags ^= 32

                            const nextHash = `${nextTile},${flags},${order}` /*2*/
                            if (!visited.has(nextHash)) {
                                // Did we see D?
                                if (flags & 16) {
                                    flags ^= 16
                                    // Set D for fish
                                    flags |= 1
                                }
                                queue.push([nextTile, steps + 1, flags, order])
                                visited.add(nextHash)
                            }
                            break;/*3*/
                        }
                    }
                    // No fish
                    else {
                        // Did we run into B?
                        if (d == 'B') {
                            //If we have D, take 1 damage else break
                            if (flags & 1)
                                flags ^= 1;
                            else
                                break;
                        }
                        // Did we run into C?
                        if (d == 'C') {
                            //If we have D, take 1 damage else break
                            if (flags & 1)
                                flags ^= 1;
                            else
                                break;
                        }
                    }
                    // Check if next tile is in visited
                    const nextHash = `${nextTile},${flags},${order}`
                    if (!visited.has(nextHash)) {
                        // Did we see D?
                        if (flags & 16) {
                            flags ^= 16
                            flags |= 1
                        }
                        // Did we see F?
                        if (flags & 32) {
                            flags ^= 32
                            // Set F for fish
                            flags |= 2
                        }

                        queue.push([nextTile, steps + 1, flags, order])
                        visited.add(nextHash)
                    }
                }
            }
        }
    }
}