static getPathIncludedDistanceMatrices(adjacencyMatrix) {
    let length = adjacencyMatrix.length;
    let d = Array(length);
    let pe = Array(length);
    let pe_prime = Array(length);
    var l = 0;
    var m = 0;
    var n = 0;
    var i = length;

    while (i--) {
      d[i] = Array(length);
      pe[i] = Array(length);
      pe_prime[i] = Array(length);
      var j = length;

      while (j--) {
        d[i][j] = i === j || adjacencyMatrix[i][j] === 1 ? adjacencyMatrix[i][j] : Number.POSITIVE_INFINITY;

        if (d[i][j] === 1) {
          pe[i][j] = [[[i, j]]];
        } else {
          pe[i][j] = Array();
        }

        pe_prime[i][j] = Array();
      }
    }

    var k = length;
    var j;

    while (k--) {
      i = length;

      while (i--) {
        j = length;

        while (j--) {
          const previousPathLength = d[i][j];
          const newPathLength = d[i][k] + d[k][j];

          if (previousPathLength > newPathLength) {
            var l, m, n;

            if (previousPathLength === newPathLength + 1) {
              pe_prime[i][j] = [pe[i][j].length];
              l = pe[i][j].length;

              while (l--) {
                pe_prime[i][j][l] = [pe[i][j][l].length];
                m = pe[i][j][l].length;

                while (m--) {
                  pe_prime[i][j][l][m] = [pe[i][j][l][m].length];
                  n = pe[i][j][l][m].length;

                  while (n--) {
                    pe_prime[i][j][l][m][n] = [pe[i][j][l][m][0], pe[i][j][l][m][1]];
                  }
                }
              }
            } else {
              pe_prime[i][j] = Array();
            }

            d[i][j] = newPathLength;
            pe[i][j] = [[]];
            l = pe[i][k][0].length;

            while (l--) {
              pe[i][j][0].push(pe[i][k][0][l]);
            }

            l = pe[k][j][0].length;

            while (l--) {
              pe[i][j][0].push(pe[k][j][0][l]);
            }
          } else if (previousPathLength === newPathLength) {
            if (pe[i][k].length && pe[k][j].length) {
              var l;

              if (pe[i][j].length) {
                let tmp = Array();
                l = pe[i][k][0].length;

                while (l--) {
                  tmp.push(pe[i][k][0][l]);
                }

                l = pe[k][j][0].length;

                while (l--) {
                  tmp.push(pe[k][j][0][l]);
                }

                pe[i][j].push(tmp);
              } else {
                let tmp = Array();
                l = pe[i][k][0].length;

                while (l--) {
                  tmp.push(pe[i][k][0][l]);
                }

                l = pe[k][j][0].length;

                while (l--) {
                  tmp.push(pe[k][j][0][l]);
                }

                pe[i][j][0] = tmp;
              }
            }
          } else if (previousPathLength === newPathLength - 1) {
            var l;

            if (pe_prime[i][j].length) {
              let tmp = Array();
              l = pe[i][k][0].length;

              while (l--) {
                tmp.push(pe[i][k][0][l]);
              }

              l = pe[k][j][0].length;

              while (l--) {
                tmp.push(pe[k][j][0][l]);
              }

              pe_prime[i][j].push(tmp);
            } else {
              let tmp = Array();
              l = pe[i][k][0].length;

              while (l--) {
                tmp.push(pe[i][k][0][l]);
              }

              l = pe[k][j][0].length;

              while (l--) {
                tmp.push(pe[k][j][0][l]);
              }

              pe_prime[i][j][0] = tmp;
            }
          }
        }
      }
    }

    return {
      d: d,
      pe: pe,
      pe_prime: pe_prime
    };
  }
Returnes the two path-included distance matrices used to find the sssr.

@param {Array[]} adjacencyMatrix An adjacency matrix.
@returns {Object} The path-included distance matrices. { p1, p2 }