....

    public static List<Integer> headElements(@Nonnull List<Integer> arg) {
        int n = arg.size();
        return arg.stream().limit(n - 1).collect(Collectors.toList());
    }
    public static List<Integer> subList(@Nonnull List<Integer> arg, int i) {
        if (arg == null) {
            throw new IllegalArgumentException("Array cannot be null!");
        }
        int n = arg.size();
        if (i < 0 || i >= n) {
            throw new IllegalArgumentException("Index is out of range");
        }
        if (i == 0) {
            if (n == 1) {
                return Collections.emptyList();
            } else {
                // TODO: Investigate for performance
                return arg.stream().skip(1).collect(Collectors.toList());
            }
        }
        if (i == n - 1) {
            // TODO: Investigate for performance
            return arg.stream().limit(n - 1).collect(Collectors.toList());
        }
        // TODO: Investigate for performance
        List<Integer> res = new ArrayList<>(arg.stream().limit(i).collect(Collectors.toList()));
        res.addAll(arg.stream().skip(i + 1).collect(Collectors.toList()));
        return res;
    }

    public static boolean isConsistent(@Nonnull List<Integer> q, int candidate) {
        int n = q.size();
        for (int i = 0; i < n; i++) {
            int qi = q.get(i);
            int deltai = n - i;
            int deltaRow = qi - candidate;
            if (Math.abs(deltaRow) == deltai) {
                return false;
            }
        }
        return true;
    }

    private static void printSolution(@Nonnull List<Integer> queens) {
        out.printf("Queens : %s\n", formatQueens(queens));
        out.printf("----------------\n");
        int n = queens.size();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                out.print(queens.get(i) == j ? "Q" : "*");
                out.print(" ");
            }
            out.println();
        }
        out.println();
    }

    // TODO: Replace with Guava or smth else
    static List<Integer> fromArray(@Nonnull int[] array) {
        List<Integer> res = new ArrayList<>(array.length);
        for (int elem : array) {
            res.add(elem);
        }
        return res;
    }


    public static String formatQueens(List<Integer> list) {
        StringBuilder sb = new StringBuilder("");
        sb.append(join(",", valueOf(list)));
        sb.append("");
        return sb.toString();
    }

    public static String formatOffset(int n){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i<n; i++) sb.append(".");
        return sb.toString();
    }

    public static void process(int n, int level, @Nonnull List<Integer> candidates, @Nonnull List<Integer> selected) {
        //out.printf("%s %d %d %s %s \n", formatOffset(level), n, level, formatQueens(candidates), formatQueens(selected));
        if (selected.size() == n) {
            // TODO: Improove overloaded isConsistent
            if (isConsistent(headElements(selected), tailElement(selected))) {
                solutions++;
                printSolution(selected);
            }
        } else {
            for (int i = 0; i < candidates.size(); i++) {
                int newCandidate = candidates.get(i);
                if (isConsistent(selected, newCandidate)) {
                    List<Integer> newSelected = new ArrayList<>(selected);
                    newSelected.add(newCandidate);
                    process(n, level + 1, subList(candidates, i), newSelected);
                }
            }
        }
    }

if (isConsistent(headElements(selected), tailElement(selected))) {

 [0, 1, 2, 3, 4, 5, 6, 7, 8] [] 
. [1, 2, 3, 4, 5, 6, 7, 8] [0] 
.. [1, 3, 4, 5, 6, 7, 8] [0, 2] 
... [1, 3, 5, 6, 7, 8] [0, 2, 4] 
.... [3, 5, 6, 7, 8] [0, 2, 4, 1] 
..... [5, 6, 7, 8] [0, 2, 4, 1, 3] 
...... [5, 6, 7] [0, 2, 4, 1, 3, 8] 
..... [3, 5, 6, 8] [0, 2, 4, 1, 7] 
..... [3, 5, 6, 7] [0, 2, 4, 1, 8] 
.... [1, 3, 5, 7, 8] [0, 2, 4, 6] 
..... [3, 5, 7, 8] [0, 2, 4, 6, 1] 
...... [5, 7, 8] [0, 2, 4, 6, 1, 3] 
....... [7, 8] [0, 2, 4, 6, 1, 3, 5] 
..... [1, 5, 7, 8] [0, 2, 4, 6, 3] 
..... [1, 3, 5, 7] [0, 2, 4, 6, 8] 
...... [1, 5, 7] [0, 2, 4, 6, 8, 3] 
....... [5, 7] [0, 2, 4, 6, 8, 3, 1] 
....... [1, 7] [0, 2, 4, 6, 8, 3, 5] 
.... [1, 3, 5, 6, 8] [0, 2, 4, 7] 
..... [3, 5, 6, 8] [0, 2, 4, 7, 1] 
...... [5, 6, 8] [0, 2, 4, 7, 1, 3] 
....... [6, 8] [0, 2, 4, 7, 1, 3, 5] 
...... [3, 5, 6] [0, 2, 4, 7, 1, 8] 
....... [3, 6] [0, 2, 4, 7, 1, 8, 5] 
..... [1, 5, 6, 8] [0, 2, 4, 7, 3] 
...... [1, 5, 6] [0, 2, 4, 7, 3, 8] 
.... [1, 3, 5, 6, 7] [0, 2, 4, 8] 
..... [3, 5, 6, 7] [0, 2, 4, 8, 1] 
...... [5, 6, 7] [0, 2, 4, 8, 1, 3] 
..... [1, 5, 6, 7] [0, 2, 4, 8, 3] 
... [1, 3, 4, 6, 7, 8] [0, 2, 5] 
.... [3, 4, 6, 7, 8] [0, 2, 5, 1] 
..... [3, 4, 7, 8] [0, 2, 5, 1, 6] 
...... [3, 7, 8] [0, 2, 5, 1, 6, 4] 
..... [3, 4, 6, 7] [0, 2, 5, 1, 8] 
...... [3, 6, 7] [0, 2, 5, 1, 8, 4] 
.... [1, 3, 4, 6, 8] [0, 2, 5, 7] 
..... [3, 4, 6, 8] [0, 2, 5, 7, 1] 
...... [4, 6, 8] [0, 2, 5, 7, 1, 3] 
....... [4, 6] [0, 2, 5, 7, 1, 3, 8] 
........ [4] [0, 2, 5, 7, 1, 3, 8, 6] 
......... [] [0, 2, 5, 7, 1, 3, 8, 6, 4] 
Found solution : [0, 2, 5, 7, 1, 3, 8, 6, 4]

static List<Integer> selected = new ArrayList<>();
    
    public static void process(int n, int level, @Nonnull List<Integer> candidates) {
        recursiveProcessCallbacks++;
        out.printf("%s %s %s \n", formatOffset(level), formatQueens(candidates), formatQueens(selected));
         if (selected.size() == n) {
            if (isConsistent(selected)) {
                solutions++;
                printSolution(selected);
            }
        } else {
            for (int i = 0; i < candidates.size(); i++) {
                int newCandidate = candidates.get(i);
                if (isConsistent(selected, newCandidate)) {
                    selected.add(newCandidate);
                    process(n, level + 1, subList(candidates, i));    
                    selected.remove(selected.size()-1);
                }
            }
        }
    }

  def process(n: Int, level: Int, candidates: List[Int], selected: List[Int]): Unit = {
    printf("%s %s %s \n", formatOffset(level,'.'), formatQueens(candidates), formatQueens(selected))
    if (selected.size == n) {
      if (isConsistent(selected)) {
        solutions += 1
        printSolution(selected,level)
      }
    } else {
      var i = 0
      while (i < candidates.size) {
        val newCandidate = candidates(i)
        if (isConsistent(selected, newCandidate)) {
          // TODO: Optimize
          var newSel: List[Int] = selected.++(List(newCandidate))
          process(n, level + 1, subList(candidates, i), newSel)
        }
        i = i + 1
      }
    }
  }

[0, 2, 4, 1, 3]
-----
Q * * * * 
* * Q * * 
* * * * Q 
* Q * * * 
* * * Q * 

[0, 3, 1, 4, 2]
-----
Q * * * * 
* * * Q * 
* Q * * * 
* * * * Q 
* * Q * * 

[1, 3, 0, 2, 4]
-----
* Q * * * 
* * * Q * 
Q * * * * 
* * Q * * 
* * * * Q 

[1, 4, 2, 0, 3]
-----
* Q * * * 
* * * * Q 
* * Q * * 
Q * * * * 
* * * Q * 

[2, 0, 3, 1, 4]
-----
* * Q * * 
Q * * * * 
* * * Q * 
* Q * * * 
* * * * Q 

[2, 4, 1, 3, 0]
-----
* * Q * * 
* * * * Q 
* Q * * * 
* * * Q * 
Q * * * * 

[3, 0, 2, 4, 1]
-----
* * * Q * 
Q * * * * 
* * Q * * 
* * * * Q 
* Q * * * 

[3, 1, 4, 2, 0]
-----
* * * Q * 
* Q * * * 
* * * * Q 
* * Q * * 
Q * * * * 

[4, 1, 3, 0, 2]
-----
* * * * Q 
* Q * * * 
* * * Q * 
Q * * * * 
* * Q * * 

[4, 2, 0, 3, 1]
-----
* * * * Q 
* * Q * * 
Q * * * * 
* * * Q * 
* Q * * *