Recursive Best-First

function rbfsPathfind(grid, start, end, allowDiag, hFn) {
  const h = hFn || HEURISTICS.manhattan;
  const prev = new Map();
  const startKey = key(start[0], start[1]);
  function rbfs(node, fLimit, pathVisited) {
    const __pattern1 = node;
    const r = __pattern1.r;
    const c = __pattern1.c;
    const g = __pattern1.g;
    const f = __pattern1.f;
    visitNode(r, c);
    if (r === end[0] && c === end[1]) {
      return {
        f,
        success: true
      };
    }
    const neighbors = [];
    for (const [nr, nc] of getNeighbors(grid, r, c, allowDiag)) {
      const neighborKey = key(nr, nc);
      if (pathVisited.has(neighborKey)) continue;
      const g2 = g + stepCost(grid, r, c, nr, nc);
      const f2 = Math.max(g2 + h(nr, nc, end[0], end[1]), f);
      neighbors.push({
        r: nr,
        c: nc,
        g: g2,
        f: f2,
        key: neighborKey
      });
      pushFrontier(nr, nc);
    }
    if (!neighbors.length) return {
      f: Infinity,
      success: false
    };
    while (neighbors.length) {
      sortByField(neighbors, "f");
      const best = neighbors[0];
      const alternative = arrayPeekValue(neighbors, 1, "f", Infinity);
      if (best.f > fLimit) return {
        f: best.f,
        success: false
      };
      if (!Number.isFinite(best.f) && !Number.isFinite(alternative)) {
        return {
          f: Infinity,
          success: false
        };
      }
      prev.set(best.key, [r, c]);
      pathVisited.add(best.key);
      const result = rbfs(best, Math.min(fLimit, alternative), pathVisited);
      pathVisited.delete(best.key);
      best.f = result.f;
      if (result.success) return result;
      prev.delete(best.key);
    }
    return {
      f: Infinity,
      success: false
    };
  }
  const startNode = {
    r: start[0],
    c: start[1],
    g: 0,
    f: h(start[0], start[1], end[0], end[1])
  };
  const result = rbfs(startNode, Infinity, new Set([startKey]));
  if (result.success) {
    reconstructPath(prev, start, end);
  } else {
    reportNoPath();
  }
}

def rbfsPathfind(grid, start, end, allowDiag, hFn):
    h = (hFn or HEURISTICS.manhattan)
    prev = Map()
    startKey = key(start[0], start[1])
    def rbfs(node, fLimit, pathVisited):
        __pattern1 = node
        r = __pattern1.r
        c = __pattern1.c
        g = __pattern1.g
        f = __pattern1.f
        visitNode(r, c)
        if ((r == end[0]) and (c == end[1])):
            return {f: f, success: True}
        neighbors = []
        for nr, nc in getNeighbors(grid, r, c, allowDiag):
            neighborKey = key(nr, nc)
            if pathVisited.has(neighborKey):
                continue
            g2 = (g + stepCost(grid, r, c, nr, nc))
            f2 = max((g2 + h(nr, nc, end[0], end[1])), f)
            neighbors.push({r: nr, c: nc, g: g2, f: f2, key: neighborKey})
            pushFrontier(nr, nc)
        if not neighbors.length:
            return {f: Infinity, success: False}
        while neighbors.length:
            sortByField(neighbors, "f")
            best = neighbors[0]
            alternative = arrayPeekValue(neighbors, 1, "f", Infinity)
            if (best.f > fLimit):
                return {f: best.f, success: False}
            if (not Number.isFinite(best.f) and not Number.isFinite(alternative)):
                return {f: Infinity, success: False}
            prev.set(best.key, [r, c])
            pathVisited.add(best.key)
            result = rbfs(best, min(fLimit, alternative), pathVisited)
            pathVisited.delete(best.key)
            best.f = result.f
            if result.success:
                return result
            prev.delete(best.key)
        return {f: Infinity, success: False}
    startNode = {r: start[0], c: start[1], g: 0, f: h(start[0], start[1], end[0], end[1])}
    result = rbfs(startNode, Infinity, Set([startKey]))
    if result.success:
        reconstructPath(prev, start, end)
    else:
        reportNoPath()

#include <vector>
#include <algorithm>
void rbfsPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    auto h = (hFn || HEURISTICS.manhattan);
    auto prev = Map();
    auto startKey = key(start[0], start[1]);
    int rbfs(int node, int fLimit, int pathVisited) {
        auto __pattern1 = node;
        auto r = __pattern1.r;
        auto c = __pattern1.c;
        auto g = __pattern1.g;
        auto f = __pattern1.f;
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            return {f: f, success: true};
        }
        auto neighbors = [];
        for(auto& [nr, nc] : getNeighbors(grid, r, c, allowDiag)) {
            auto neighborKey = key(nr, nc);
            if(pathVisited.has(neighborKey)) {
                continue;
            }
            auto g2 = (g + stepCost(grid, r, c, nr, nc));
            auto f2 = (((g2 + h(nr, nc, end[0], end[1]))) > (f) ? ((g2 + h(nr, nc, end[0], end[1]))) : (f));
            neighbors.push({r: nr, c: nc, g: g2, f: f2, key: neighborKey});
            pushFrontier(nr, nc);
        }
        if(!neighbors.length) {
            return {f: Infinity, success: false};
        }
        while(neighbors.length) {
            sortByField(neighbors, "f");
            auto best = neighbors[0];
            auto alternative = arrayPeekValue(neighbors, 1, "f", Infinity);
            if((best.f > fLimit)) {
                return {f: best.f, success: false};
            }
            if((!Number.isFinite(best.f) && !Number.isFinite(alternative))) {
                return {f: Infinity, success: false};
            }
            prev.set(best.key, [r, c]);
            pathVisited.add(best.key);
            auto result = rbfs(best, ((fLimit) < (alternative) ? (fLimit) : (alternative)), pathVisited);
            pathVisited.delete(best.key);
            best.f = result.f;
            if(result.success) {
                return result;
            }
            prev.delete(best.key);
        }
        return {f: Infinity, success: false};
    }
    auto startNode = {r: start[0], c: start[1], g: 0, f: h(start[0], start[1], end[0], end[1])};
    auto result = rbfs(startNode, Infinity, Set([startKey]));
    if(result.success) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}

public void rbfsPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var startKey = key(start[0], start[1]);
    int rbfs(int node, int fLimit, int pathVisited) {
        var __pattern1 = node;
        var r = __pattern1.r;
        var c = __pattern1.c;
        var g = __pattern1.g;
        var f = __pattern1.f;
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            return {f: f, success: true};
        }
        var neighbors = [];
        foreach(var (nr, nc) in getNeighbors(grid, r, c, allowDiag)) {
            var neighborKey = key(nr, nc);
            if(pathVisited.has(neighborKey)) {
                continue;
            }
            var g2 = (g + stepCost(grid, r, c, nr, nc));
            var f2 = Math.Max((g2 + h(nr, nc, end[0], end[1])), f);
            neighbors.push({r: nr, c: nc, g: g2, f: f2, key: neighborKey});
            pushFrontier(nr, nc);
        }
        if(!neighbors.length) {
            return {f: Infinity, success: false};
        }
        while(neighbors.length) {
            sortByField(neighbors, "f");
            var best = neighbors[0];
            var alternative = arrayPeekValue(neighbors, 1, "f", Infinity);
            if((best.f > fLimit)) {
                return {f: best.f, success: false};
            }
            if((!Number.isFinite(best.f) && !Number.isFinite(alternative))) {
                return {f: Infinity, success: false};
            }
            prev.set(best.key, [r, c]);
            pathVisited.add(best.key);
            var result = rbfs(best, Math.Min(fLimit, alternative), pathVisited);
            pathVisited.delete(best.key);
            best.f = result.f;
            if(result.success) {
                return result;
            }
            prev.delete(best.key);
        }
        return {f: Infinity, success: false};
    }
    var startNode = {r: start[0], c: start[1], g: 0, f: h(start[0], start[1], end[0], end[1])};
    var result = rbfs(startNode, Infinity, Set([startKey]));
    if(result.success) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}

#include <stdio.h>
void rbfsPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var startKey = key(start[0], start[1]);
    int rbfs(int node, int fLimit, int pathVisited) {
        var __pattern1 = node;
        var r = __pattern1.r;
        var c = __pattern1.c;
        var g = __pattern1.g;
        var f = __pattern1.f;
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            return {f: f, success: true};
        }
        var neighbors = [];
        for(int _fod_i = 0; _fod_i < getNeighbors(grid, r, c, allowDiag)_len; _fod_i++) {
            int nr = getNeighbors(grid, r, c, allowDiag)[_fod_i][0];
            int nc = getNeighbors(grid, r, c, allowDiag)[_fod_i][1];
            var neighborKey = key(nr, nc);
            if(pathVisited.has(neighborKey)) {
                continue;
            }
            var g2 = (g + stepCost(grid, r, c, nr, nc));
            var f2 = (((g2 + h(nr, nc, end[0], end[1]))) > (f) ? ((g2 + h(nr, nc, end[0], end[1]))) : (f));
            neighbors.push({r: nr, c: nc, g: g2, f: f2, key: neighborKey});
            pushFrontier(nr, nc);
        }
        if(!neighbors.length) {
            return {f: Infinity, success: false};
        }
        while(neighbors.length) {
            sortByField(neighbors, "f");
            var best = neighbors[0];
            var alternative = arrayPeekValue(neighbors, 1, "f", Infinity);
            if((best.f > fLimit)) {
                return {f: best.f, success: false};
            }
            if((!Number.isFinite(best.f) && !Number.isFinite(alternative))) {
                return {f: Infinity, success: false};
            }
            prev.set(best.key, [r, c]);
            pathVisited.add(best.key);
            var result = rbfs(best, ((fLimit) < (alternative) ? (fLimit) : (alternative)), pathVisited);
            pathVisited.delete(best.key);
            best.f = result.f;
            if(result.success) {
                return result;
            }
            prev.delete(best.key);
        }
        return {f: Infinity, success: false};
    }
    var startNode = {r: start[0], c: start[1], g: 0, f: h(start[0], start[1], end[0], end[1])};
    var result = rbfs(startNode, Infinity, Set([startKey]));
    if(result.success) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}