function solve(arr) {
  let pool = {};

  let nestObj = {};

  let i = 0;

  let skillsTotal = 0;

  let skillArr = [];

  let sortingArr = [];

  while (arr[i] !== "Ave Cesar") {
    let arr2 = arr[i].split(" ");

    if (arr2.length > 3) {
      let curEl = arr[i].split(" -> ");

      if (!pool.hasOwnProperty(curEl[0])) {
        nestObj[curEl[1]] = curEl[2];

        pool[curEl[0]] = nestObj;

        nestObj = {};
      } else {
        if (pool[curEl[0]].hasOwnProperty(curEl[1])) {
          if (pool[curEl[0]][curEl[1]] < curEl[2]) {
            pool[curEl[0]][curEl[1]] = curEl[2];
          }
        } else {
          pool[curEl[0]][curEl[1]] = curEl[2];
        }
      }
    } else {
      let curEl = arr[i].split(" vs ");

      let gladOne = curEl[0];

      let gladTwo = curEl[1];

      if (!pool.hasOwnProperty(gladOne) || !pool.hasOwnProperty(gladTwo)) {
        i++;

        continue;
      }

      let tehArr = Object.keys(pool[gladOne]);

      let tehArr2 = Object.keys(pool[gladTwo]);

      if (tehArr.some((el) => tehArr2.includes(el))) {
        let losingSide = [];

        for (let el of curEl) {
          for (let key in pool[el]) {
            losingSide.push([el, pool[el][key]]);
          }
        }

        losingSide.sort((a, b) => a[1] - b[1]);

        losingSide.pop();

        losingSide = losingSide.flat();

        losingSide = losingSide[0];

        delete pool[losingSide];
      }
    }

    i++;
  }

  for (let key in pool) {
    skillArr = Object.entries(pool[key])
      .flat()
      .filter((el) => (!isNaN(el) ? el : false));

    skillsTotal = skillArr.reduce((acc, el) => acc + Number(el), 0);

    pool[key].skill = skillsTotal;
  }

  for (let key in pool) {
    sortingArr.push([key, pool[key]]);
  }

  sortingArr.sort((a, b) =>
    b[1]["skill"] !== a[1]["skill"]
      ? b[1]["skill"] - a[1]["skill"]
      : a[0].localeCompare(b[0])
  );

  for (let i = 0; i < sortingArr.length; i++) {
    let subsection = Object.entries(sortingArr[i][1]).sort((a, b) =>
      b[1] !== a[1] ? b[1] - a[1] : a[0].localeCompare(b[0])
    );

    sortingArr[i].splice(1, 1, subsection);
  }

  for (let i = 0; i < sortingArr.length; i++) {
    console.log(`${sortingArr[i][0]}: ${sortingArr[i][1][0][1]} skill`);

    sortingArr[i][1].forEach((el) =>
      el[0] === "skill"
        ? sortingArr[i][1].splice(sortingArr[i][1].indexOf(el), 1)
        : false
    );

    sortingArr[i].shift();

    sortingArr[i] = sortingArr[i].flat();

    for (let j = 0; j < sortingArr[i].length; j++) {
      console.log(`- ${sortingArr[i][j][0]} <!> ${sortingArr[i][j][1]}`);
    }
  }

  // console.log(sortingArr);
}