astar2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create 2 Dimension array to represent search grid\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4644db501b9248868cae75286e585477",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Rows')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1bb3f76050d494194ed2c8d19fa9d95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1c3c6ad66ec847e482dac8368d5f8b60",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Columns')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5847648fd7674a36a8a589ec08b297fc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "29aab65be8264864b4d3ad6f3880c937",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Create Grid', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e6bd64a74bf64d5183f2fd126e76c160",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Run ASTAR', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After creating the grid space click the Run ASTAR button\n",
      "Current Node:  (0, 8)\n",
      "Unsuccessful goal check number:  1\n",
      "Closed Nodes:  {(0, 8)}\n",
      "\n",
      "Main for-loop iteration:  1\n",
      "The currentNode is:  (0, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 9) in iteration:  1\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 9) is on the array\n",
      "neighborNode (0, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 9)\n",
      "index after cast:  [0, 9]\n",
      "Obtain cost of node: [ 0 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 9) without adding parent cost is:  1\n",
      "g cost of parent node:  (0, 8) is:  0\n",
      "g cost of neighborNode:  (0, 9) plus its parentNode's:  (0, 8) g cost is:  1\n",
      "(0, 9)  added to open list\n",
      "h of neighborNode:  (0, 9) is:  17\n",
      "f cost of neighborNode:  (0, 9) is:  18\n",
      "\n",
      "Main for-loop iteration:  2\n",
      "The currentNode is:  (0, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 8) in iteration:  2\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 8) is on the array\n",
      "neighborNode (1, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 8)\n",
      "index after cast:  [1, 8]\n",
      "Obtain cost of node: [ 1 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (1, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 8) is:  0\n",
      "g cost of neighborNode:  (1, 8) plus its parentNode's:  (0, 8) g cost is:  9\n",
      "(1, 8)  added to open list\n",
      "h of neighborNode:  (1, 8) is:  15\n",
      "f cost of neighborNode:  (1, 8) is:  24\n",
      "\n",
      "Main for-loop iteration:  3\n",
      "The currentNode is:  (0, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 8) in iteration:  3\n",
      "(-1, 8) :not on array\n",
      "\n",
      "Main for-loop iteration:  4\n",
      "The currentNode is:  (0, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 7) in iteration:  4\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 7) is on the array\n",
      "neighborNode (0, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 7)\n",
      "index after cast:  [0, 7]\n",
      "Obtain cost of node: [ 0 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (0, 8) is:  0\n",
      "g cost of neighborNode:  (0, 7) plus its parentNode's:  (0, 8) g cost is:  1\n",
      "(0, 7)  added to open list\n",
      "h of neighborNode:  (0, 7) is:  15\n",
      "f cost of neighborNode:  (0, 7) is:  16\n",
      "Current Node:  (0, 7)\n",
      "Unsuccessful goal check number:  2\n",
      "Closed Nodes:  {(0, 8), (0, 7)}\n",
      "\n",
      "Main for-loop iteration:  5\n",
      "The currentNode is:  (0, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 8) in iteration:  5\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 8) is on the array\n",
      "neighborNode (0, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 8)\n",
      "index after cast:  [0, 8]\n",
      "Obtain cost of node: [ 0 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 8) without adding parent cost is:  4\n",
      "g cost of parent node:  (0, 7) is:  1\n",
      "g cost of neighborNode:  (0, 8) plus its parentNode's:  (0, 7) g cost is:  5\n",
      "(0, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  6\n",
      "The currentNode is:  (0, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 7) in iteration:  6\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 7) is on the array\n",
      "neighborNode (1, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 7)\n",
      "index after cast:  [1, 7]\n",
      "Obtain cost of node: [ 1 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (0, 7) is:  1\n",
      "g cost of neighborNode:  (1, 7) plus its parentNode's:  (0, 7) g cost is:  6\n",
      "(1, 7)  added to open list\n",
      "h of neighborNode:  (1, 7) is:  14\n",
      "f cost of neighborNode:  (1, 7) is:  20\n",
      "\n",
      "Main for-loop iteration:  7\n",
      "The currentNode is:  (0, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 7) in iteration:  7\n",
      "(-1, 7) :not on array\n",
      "\n",
      "Main for-loop iteration:  8\n",
      "The currentNode is:  (0, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 6) in iteration:  8\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 6) is on the array\n",
      "neighborNode (0, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 6)\n",
      "index after cast:  [0, 6]\n",
      "Obtain cost of node: [ 0 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 6) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 7) is:  1\n",
      "g cost of neighborNode:  (0, 6) plus its parentNode's:  (0, 7) g cost is:  10\n",
      "(0, 6)  added to open list\n",
      "h of neighborNode:  (0, 6) is:  14\n",
      "f cost of neighborNode:  (0, 6) is:  24\n",
      "Current Node:  (0, 9)\n",
      "Unsuccessful goal check number:  3\n",
      "Closed Nodes:  {(0, 9), (0, 8), (0, 7)}\n",
      "\n",
      "Main for-loop iteration:  9\n",
      "The currentNode is:  (0, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 10) in iteration:  9\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(0, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  10\n",
      "The currentNode is:  (0, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 9) in iteration:  10\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 9) is on the array\n",
      "neighborNode (1, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 9)\n",
      "index after cast:  [1, 9]\n",
      "Obtain cost of node: [ 1 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 9) without adding parent cost is:  5\n",
      "g cost of parent node:  (0, 9) is:  1\n",
      "g cost of neighborNode:  (1, 9) plus its parentNode's:  (0, 9) g cost is:  6\n",
      "(1, 9)  added to open list\n",
      "h of neighborNode:  (1, 9) is:  16\n",
      "f cost of neighborNode:  (1, 9) is:  22\n",
      "\n",
      "Main for-loop iteration:  11\n",
      "The currentNode is:  (0, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 9) in iteration:  11\n",
      "(-1, 9) :not on array\n",
      "\n",
      "Main for-loop iteration:  12\n",
      "The currentNode is:  (0, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 8) in iteration:  12\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 8) is on the array\n",
      "neighborNode (0, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 8)\n",
      "index after cast:  [0, 8]\n",
      "Obtain cost of node: [ 0 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 8) without adding parent cost is:  4\n",
      "g cost of parent node:  (0, 9) is:  1\n",
      "g cost of neighborNode:  (0, 8) plus its parentNode's:  (0, 9) g cost is:  5\n",
      "(0, 8) not pushed\n",
      "Current Node:  (1, 7)\n",
      "Unsuccessful goal check number:  4\n",
      "Closed Nodes:  {(0, 9), (0, 8), (0, 7), (1, 7)}\n",
      "\n",
      "Main for-loop iteration:  13\n",
      "The currentNode is:  (1, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 8) in iteration:  13\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 8) is on the array\n",
      "neighborNode (1, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 8)\n",
      "index after cast:  [1, 8]\n",
      "Obtain cost of node: [ 1 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (1, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 7) is:  6\n",
      "g cost of neighborNode:  (1, 8) plus its parentNode's:  (1, 7) g cost is:  15\n",
      "\n",
      "Main for-loop iteration:  14\n",
      "The currentNode is:  (1, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 7) in iteration:  14\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 7) is on the array\n",
      "neighborNode (2, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 7)\n",
      "index after cast:  [2, 7]\n",
      "Obtain cost of node: [ 2 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (2, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (1, 7) is:  6\n",
      "g cost of neighborNode:  (2, 7) plus its parentNode's:  (1, 7) g cost is:  10\n",
      "(2, 7)  added to open list\n",
      "h of neighborNode:  (2, 7) is:  13\n",
      "f cost of neighborNode:  (2, 7) is:  23\n",
      "\n",
      "Main for-loop iteration:  15\n",
      "The currentNode is:  (1, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 7) in iteration:  15\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 7) is on the array\n",
      "neighborNode (0, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 7)\n",
      "index after cast:  [0, 7]\n",
      "Obtain cost of node: [ 0 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (1, 7) is:  6\n",
      "g cost of neighborNode:  (0, 7) plus its parentNode's:  (1, 7) g cost is:  7\n",
      "(0, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  16\n",
      "The currentNode is:  (1, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 6) in iteration:  16\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 6) is on the array\n",
      "neighborNode (1, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 6)\n",
      "index after cast:  [1, 6]\n",
      "Obtain cost of node: [ 1 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (1, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (1, 7) is:  6\n",
      "g cost of neighborNode:  (1, 6) plus its parentNode's:  (1, 7) g cost is:  9\n",
      "(1, 6)  added to open list\n",
      "h of neighborNode:  (1, 6) is:  13\n",
      "f cost of neighborNode:  (1, 6) is:  22\n",
      "Current Node:  (1, 6)\n",
      "Unsuccessful goal check number:  5\n",
      "Closed Nodes:  {(0, 7), (1, 6), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  17\n",
      "The currentNode is:  (1, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 7) in iteration:  17\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 7) is on the array\n",
      "neighborNode (1, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 7)\n",
      "index after cast:  [1, 7]\n",
      "Obtain cost of node: [ 1 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (1, 6) is:  9\n",
      "g cost of neighborNode:  (1, 7) plus its parentNode's:  (1, 6) g cost is:  14\n",
      "(1, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  18\n",
      "The currentNode is:  (1, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 6) in iteration:  18\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 6) is on the array\n",
      "neighborNode (2, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 6)\n",
      "index after cast:  [2, 6]\n",
      "Obtain cost of node: [ 2 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (2, 6) without adding parent cost is:  7\n",
      "g cost of parent node:  (1, 6) is:  9\n",
      "g cost of neighborNode:  (2, 6) plus its parentNode's:  (1, 6) g cost is:  16\n",
      "(2, 6)  added to open list\n",
      "h of neighborNode:  (2, 6) is:  12\n",
      "f cost of neighborNode:  (2, 6) is:  28\n",
      "\n",
      "Main for-loop iteration:  19\n",
      "The currentNode is:  (1, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 6) in iteration:  19\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 6) is on the array\n",
      "neighborNode (0, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 6)\n",
      "index after cast:  [0, 6]\n",
      "Obtain cost of node: [ 0 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 6) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 6) is:  9\n",
      "g cost of neighborNode:  (0, 6) plus its parentNode's:  (1, 6) g cost is:  18\n",
      "\n",
      "Main for-loop iteration:  20\n",
      "The currentNode is:  (1, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 5) in iteration:  20\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 5) is on the array\n",
      "neighborNode (1, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (1, 6) is:  9\n",
      "g cost of neighborNode:  (1, 5) plus its parentNode's:  (1, 6) g cost is:  11\n",
      "(1, 5)  added to open list\n",
      "h of neighborNode:  (1, 5) is:  12\n",
      "f cost of neighborNode:  (1, 5) is:  23\n",
      "Current Node:  (1, 9)\n",
      "Unsuccessful goal check number:  6\n",
      "Closed Nodes:  {(0, 7), (1, 6), (1, 9), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  21\n",
      "The currentNode is:  (1, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 10) in iteration:  21\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(1, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  22\n",
      "The currentNode is:  (1, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 9) in iteration:  22\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 9) is on the array\n",
      "neighborNode (2, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 9)\n",
      "index after cast:  [2, 9]\n",
      "Obtain cost of node: [ 2 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (2, 9) without adding parent cost is:  1\n",
      "g cost of parent node:  (1, 9) is:  6\n",
      "g cost of neighborNode:  (2, 9) plus its parentNode's:  (1, 9) g cost is:  7\n",
      "(2, 9)  added to open list\n",
      "h of neighborNode:  (2, 9) is:  15\n",
      "f cost of neighborNode:  (2, 9) is:  22\n",
      "\n",
      "Main for-loop iteration:  23\n",
      "The currentNode is:  (1, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 9) in iteration:  23\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 9) is on the array\n",
      "neighborNode (0, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 9)\n",
      "index after cast:  [0, 9]\n",
      "Obtain cost of node: [ 0 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 9) without adding parent cost is:  1\n",
      "g cost of parent node:  (1, 9) is:  6\n",
      "g cost of neighborNode:  (0, 9) plus its parentNode's:  (1, 9) g cost is:  7\n",
      "(0, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  24\n",
      "The currentNode is:  (1, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 8) in iteration:  24\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 8) is on the array\n",
      "neighborNode (1, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 8)\n",
      "index after cast:  [1, 8]\n",
      "Obtain cost of node: [ 1 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (1, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 9) is:  6\n",
      "g cost of neighborNode:  (1, 8) plus its parentNode's:  (1, 9) g cost is:  15\n",
      "Current Node:  (2, 9)\n",
      "Unsuccessful goal check number:  7\n",
      "Closed Nodes:  {(2, 9), (0, 7), (1, 6), (1, 9), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  25\n",
      "The currentNode is:  (2, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 10) in iteration:  25\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(2, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  26\n",
      "The currentNode is:  (2, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 9) in iteration:  26\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 9) is on the array\n",
      "neighborNode (3, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 9)\n",
      "index after cast:  [3, 9]\n",
      "Obtain cost of node: [ 3 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (3, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (2, 9) is:  7\n",
      "g cost of neighborNode:  (3, 9) plus its parentNode's:  (2, 9) g cost is:  13\n",
      "(3, 9)  added to open list\n",
      "h of neighborNode:  (3, 9) is:  14\n",
      "f cost of neighborNode:  (3, 9) is:  27\n",
      "\n",
      "Main for-loop iteration:  27\n",
      "The currentNode is:  (2, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 9) in iteration:  27\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 9) is on the array\n",
      "neighborNode (1, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 9)\n",
      "index after cast:  [1, 9]\n",
      "Obtain cost of node: [ 1 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 9) without adding parent cost is:  5\n",
      "g cost of parent node:  (2, 9) is:  7\n",
      "g cost of neighborNode:  (1, 9) plus its parentNode's:  (2, 9) g cost is:  12\n",
      "(1, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  28\n",
      "The currentNode is:  (2, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 8) in iteration:  28\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 8) is on the array\n",
      "neighborNode (2, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 8)\n",
      "index after cast:  [2, 8]\n",
      "Obtain cost of node: [ 2 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (2, 9) is:  7\n",
      "g cost of neighborNode:  (2, 8) plus its parentNode's:  (2, 9) g cost is:  15\n",
      "(2, 8)  added to open list\n",
      "h of neighborNode:  (2, 8) is:  14\n",
      "f cost of neighborNode:  (2, 8) is:  29\n",
      "Current Node:  (1, 5)\n",
      "Unsuccessful goal check number:  8\n",
      "Closed Nodes:  {(2, 9), (0, 7), (1, 5), (1, 6), (1, 9), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  29\n",
      "The currentNode is:  (1, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 6) in iteration:  29\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 6) is on the array\n",
      "neighborNode (1, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 6)\n",
      "index after cast:  [1, 6]\n",
      "Obtain cost of node: [ 1 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (1, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (1, 5) is:  11\n",
      "g cost of neighborNode:  (1, 6) plus its parentNode's:  (1, 5) g cost is:  14\n",
      "(1, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  30\n",
      "The currentNode is:  (1, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 5) in iteration:  30\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 5) is on the array\n",
      "neighborNode (2, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 5)\n",
      "index after cast:  [2, 5]\n",
      "Obtain cost of node: [ 2 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (2, 5) without adding parent cost is:  3\n",
      "g cost of parent node:  (1, 5) is:  11\n",
      "g cost of neighborNode:  (2, 5) plus its parentNode's:  (1, 5) g cost is:  14\n",
      "(2, 5)  added to open list\n",
      "h of neighborNode:  (2, 5) is:  11\n",
      "f cost of neighborNode:  (2, 5) is:  25\n",
      "\n",
      "Main for-loop iteration:  31\n",
      "The currentNode is:  (1, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 5) in iteration:  31\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 5) is on the array\n",
      "neighborNode (0, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 5)\n",
      "index after cast:  [0, 5]\n",
      "Obtain cost of node: [ 0 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (1, 5) is:  11\n",
      "g cost of neighborNode:  (0, 5) plus its parentNode's:  (1, 5) g cost is:  12\n",
      "(0, 5)  added to open list\n",
      "h of neighborNode:  (0, 5) is:  13\n",
      "f cost of neighborNode:  (0, 5) is:  25\n",
      "\n",
      "Main for-loop iteration:  32\n",
      "The currentNode is:  (1, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 4) in iteration:  32\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 4) is on the array\n",
      "neighborNode (1, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 4)\n",
      "index after cast:  [1, 4]\n",
      "Obtain cost of node: [ 1 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (1, 5) is:  11\n",
      "g cost of neighborNode:  (1, 4) plus its parentNode's:  (1, 5) g cost is:  13\n",
      "(1, 4)  added to open list\n",
      "h of neighborNode:  (1, 4) is:  11\n",
      "f cost of neighborNode:  (1, 4) is:  24\n",
      "Current Node:  (2, 7)\n",
      "Unsuccessful goal check number:  9\n",
      "Closed Nodes:  {(2, 7), (2, 9), (0, 7), (1, 5), (1, 6), (1, 9), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  33\n",
      "The currentNode is:  (2, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 8) in iteration:  33\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 8) is on the array\n",
      "neighborNode (2, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 8)\n",
      "index after cast:  [2, 8]\n",
      "Obtain cost of node: [ 2 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (2, 7) is:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g cost of neighborNode:  (2, 8) plus its parentNode's:  (2, 7) g cost is:  18\n",
      "\n",
      "Main for-loop iteration:  34\n",
      "The currentNode is:  (2, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 7) in iteration:  34\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 7) is on the array\n",
      "neighborNode (3, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 7)\n",
      "index after cast:  [3, 7]\n",
      "Obtain cost of node: [ 3 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (3, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (2, 7) is:  10\n",
      "g cost of neighborNode:  (3, 7) plus its parentNode's:  (2, 7) g cost is:  14\n",
      "(3, 7)  added to open list\n",
      "h of neighborNode:  (3, 7) is:  12\n",
      "f cost of neighborNode:  (3, 7) is:  26\n",
      "\n",
      "Main for-loop iteration:  35\n",
      "The currentNode is:  (2, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 7) in iteration:  35\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 7) is on the array\n",
      "neighborNode (1, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 7)\n",
      "index after cast:  [1, 7]\n",
      "Obtain cost of node: [ 1 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (2, 7) is:  10\n",
      "g cost of neighborNode:  (1, 7) plus its parentNode's:  (2, 7) g cost is:  15\n",
      "(1, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  36\n",
      "The currentNode is:  (2, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 6) in iteration:  36\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 6) is on the array\n",
      "neighborNode (2, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 6)\n",
      "index after cast:  [2, 6]\n",
      "Obtain cost of node: [ 2 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (2, 6) without adding parent cost is:  7\n",
      "g cost of parent node:  (2, 7) is:  10\n",
      "g cost of neighborNode:  (2, 6) plus its parentNode's:  (2, 7) g cost is:  17\n",
      "Current Node:  (0, 6)\n",
      "Unsuccessful goal check number:  10\n",
      "Closed Nodes:  {(2, 7), (2, 9), (0, 7), (1, 5), (0, 6), (1, 6), (1, 9), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  37\n",
      "The currentNode is:  (0, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 7) in iteration:  37\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 7) is on the array\n",
      "neighborNode (0, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 7)\n",
      "index after cast:  [0, 7]\n",
      "Obtain cost of node: [ 0 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (0, 6) is:  10\n",
      "g cost of neighborNode:  (0, 7) plus its parentNode's:  (0, 6) g cost is:  11\n",
      "(0, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  38\n",
      "The currentNode is:  (0, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 6) in iteration:  38\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 6) is on the array\n",
      "neighborNode (1, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 6)\n",
      "index after cast:  [1, 6]\n",
      "Obtain cost of node: [ 1 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (1, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (0, 6) is:  10\n",
      "g cost of neighborNode:  (1, 6) plus its parentNode's:  (0, 6) g cost is:  13\n",
      "(1, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  39\n",
      "The currentNode is:  (0, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 6) in iteration:  39\n",
      "(-1, 6) :not on array\n",
      "\n",
      "Main for-loop iteration:  40\n",
      "The currentNode is:  (0, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 5) in iteration:  40\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 5) is on the array\n",
      "neighborNode (0, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 5)\n",
      "index after cast:  [0, 5]\n",
      "Obtain cost of node: [ 0 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (0, 6) is:  10\n",
      "g cost of neighborNode:  (0, 5) plus its parentNode's:  (0, 6) g cost is:  11\n",
      "(0, 5)  added to open list\n",
      "h of neighborNode:  (0, 5) is:  13\n",
      "f cost of neighborNode:  (0, 5) is:  24\n",
      "Current Node:  (0, 5)\n",
      "Unsuccessful goal check number:  11\n",
      "Closed Nodes:  {(2, 7), (2, 9), (0, 7), (1, 5), (0, 6), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  41\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 6) in iteration:  41\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 6) is on the array\n",
      "neighborNode (0, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 6)\n",
      "index after cast:  [0, 6]\n",
      "Obtain cost of node: [ 0 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 6) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (0, 6) plus its parentNode's:  (0, 5) g cost is:  20\n",
      "(0, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  42\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 5) in iteration:  42\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 5) is on the array\n",
      "neighborNode (1, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (1, 5) plus its parentNode's:  (0, 5) g cost is:  13\n",
      "(1, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  43\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 5) in iteration:  43\n",
      "(-1, 5) :not on array\n",
      "\n",
      "Main for-loop iteration:  44\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 4) in iteration:  44\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 4) is on the array\n",
      "neighborNode (0, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 4)\n",
      "index after cast:  [0, 4]\n",
      "Obtain cost of node: [ 0 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 4) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (0, 4) plus its parentNode's:  (0, 5) g cost is:  20\n",
      "(0, 4)  added to open list\n",
      "h of neighborNode:  (0, 4) is:  12\n",
      "f cost of neighborNode:  (0, 4) is:  32\n",
      "Current Node:  (1, 4)\n",
      "Unsuccessful goal check number:  12\n",
      "Closed Nodes:  {(2, 7), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  45\n",
      "The currentNode is:  (1, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 5) in iteration:  45\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 5) is on the array\n",
      "neighborNode (1, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (1, 4) is:  13\n",
      "g cost of neighborNode:  (1, 5) plus its parentNode's:  (1, 4) g cost is:  15\n",
      "(1, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  46\n",
      "The currentNode is:  (1, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 4) in iteration:  46\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 4) is on the array\n",
      "neighborNode (2, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 4)\n",
      "index after cast:  [2, 4]\n",
      "Obtain cost of node: [ 2 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (2, 4) without adding parent cost is:  0\n",
      "g cost of parent node:  (1, 4) is:  13\n",
      "g cost of neighborNode:  (2, 4) plus its parentNode's:  (1, 4) g cost is:  13\n",
      "(2, 4)  added to open list\n",
      "h of neighborNode:  (2, 4) is:  10\n",
      "f cost of neighborNode:  (2, 4) is:  23\n",
      "\n",
      "Main for-loop iteration:  47\n",
      "The currentNode is:  (1, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 4) in iteration:  47\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 4) is on the array\n",
      "neighborNode (0, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 4)\n",
      "index after cast:  [0, 4]\n",
      "Obtain cost of node: [ 0 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 4) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 4) is:  13\n",
      "g cost of neighborNode:  (0, 4) plus its parentNode's:  (1, 4) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  48\n",
      "The currentNode is:  (1, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 3) in iteration:  48\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 3) is on the array\n",
      "neighborNode (1, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 3)\n",
      "index after cast:  [1, 3]\n",
      "Obtain cost of node: [ 1 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (1, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (1, 4) is:  13\n",
      "g cost of neighborNode:  (1, 3) plus its parentNode's:  (1, 4) g cost is:  13\n",
      "(1, 3)  added to open list\n",
      "h of neighborNode:  (1, 3) is:  10\n",
      "f cost of neighborNode:  (1, 3) is:  23\n",
      "Current Node:  (1, 3)\n",
      "Unsuccessful goal check number:  13\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 8)}\n",
      "\n",
      "Main for-loop iteration:  49\n",
      "The currentNode is:  (1, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 4) in iteration:  49\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 4) is on the array\n",
      "neighborNode (1, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 4)\n",
      "index after cast:  [1, 4]\n",
      "Obtain cost of node: [ 1 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (1, 3) is:  13\n",
      "g cost of neighborNode:  (1, 4) plus its parentNode's:  (1, 3) g cost is:  15\n",
      "(1, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  50\n",
      "The currentNode is:  (1, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 3) in iteration:  50\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 3) is on the array\n",
      "neighborNode (2, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 3)\n",
      "index after cast:  [2, 3]\n",
      "Obtain cost of node: [ 2 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 3) without adding parent cost is:  8\n",
      "g cost of parent node:  (1, 3) is:  13\n",
      "g cost of neighborNode:  (2, 3) plus its parentNode's:  (1, 3) g cost is:  21\n",
      "(2, 3)  added to open list\n",
      "h of neighborNode:  (2, 3) is:  9\n",
      "f cost of neighborNode:  (2, 3) is:  30\n",
      "\n",
      "Main for-loop iteration:  51\n",
      "The currentNode is:  (1, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 3) in iteration:  51\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 3) is on the array\n",
      "neighborNode (0, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 3)\n",
      "index after cast:  [0, 3]\n",
      "Obtain cost of node: [ 0 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (0, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (1, 3) is:  13\n",
      "g cost of neighborNode:  (0, 3) plus its parentNode's:  (1, 3) g cost is:  13\n",
      "(0, 3)  added to open list\n",
      "h of neighborNode:  (0, 3) is:  11\n",
      "f cost of neighborNode:  (0, 3) is:  24\n",
      "\n",
      "Main for-loop iteration:  52\n",
      "The currentNode is:  (1, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 2) in iteration:  52\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 2) is on the array\n",
      "neighborNode (1, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 2)\n",
      "index after cast:  [1, 2]\n",
      "Obtain cost of node: [ 1 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 2) without adding parent cost is:  5\n",
      "g cost of parent node:  (1, 3) is:  13\n",
      "g cost of neighborNode:  (1, 2) plus its parentNode's:  (1, 3) g cost is:  18\n",
      "(1, 2)  added to open list\n",
      "h of neighborNode:  (1, 2) is:  9\n",
      "f cost of neighborNode:  (1, 2) is:  27\n",
      "Current Node:  (2, 4)\n",
      "Unsuccessful goal check number:  14\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 8), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  53\n",
      "The currentNode is:  (2, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 5) in iteration:  53\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 5) is on the array\n",
      "neighborNode (2, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 5)\n",
      "index after cast:  [2, 5]\n",
      "Obtain cost of node: [ 2 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (2, 5) without adding parent cost is:  3\n",
      "g cost of parent node:  (2, 4) is:  13\n",
      "g cost of neighborNode:  (2, 5) plus its parentNode's:  (2, 4) g cost is:  16\n",
      "\n",
      "Main for-loop iteration:  54\n",
      "The currentNode is:  (2, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 4) in iteration:  54\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 4) is on the array\n",
      "neighborNode (3, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (2, 4) is:  13\n",
      "g cost of neighborNode:  (3, 4) plus its parentNode's:  (2, 4) g cost is:  15\n",
      "(3, 4)  added to open list\n",
      "h of neighborNode:  (3, 4) is:  9\n",
      "f cost of neighborNode:  (3, 4) is:  24\n",
      "\n",
      "Main for-loop iteration:  55\n",
      "The currentNode is:  (2, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 4) in iteration:  55\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 4) is on the array\n",
      "neighborNode (1, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 4)\n",
      "index after cast:  [1, 4]\n",
      "Obtain cost of node: [ 1 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (2, 4) is:  13\n",
      "g cost of neighborNode:  (1, 4) plus its parentNode's:  (2, 4) g cost is:  15\n",
      "(1, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  56\n",
      "The currentNode is:  (2, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 3) in iteration:  56\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 3) is on the array\n",
      "neighborNode (2, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 3)\n",
      "index after cast:  [2, 3]\n",
      "Obtain cost of node: [ 2 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 3) without adding parent cost is:  8\n",
      "g cost of parent node:  (2, 4) is:  13\n",
      "g cost of neighborNode:  (2, 3) plus its parentNode's:  (2, 4) g cost is:  21\n",
      "Current Node:  (0, 3)\n",
      "Unsuccessful goal check number:  15\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 3), (0, 8), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  57\n",
      "The currentNode is:  (0, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 4) in iteration:  57\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 4) is on the array\n",
      "neighborNode (0, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 4)\n",
      "index after cast:  [0, 4]\n",
      "Obtain cost of node: [ 0 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 4) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 3) is:  13\n",
      "g cost of neighborNode:  (0, 4) plus its parentNode's:  (0, 3) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  58\n",
      "The currentNode is:  (0, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 3) in iteration:  58\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 3) is on the array\n",
      "neighborNode (1, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 3)\n",
      "index after cast:  [1, 3]\n",
      "Obtain cost of node: [ 1 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (1, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (0, 3) is:  13\n",
      "g cost of neighborNode:  (1, 3) plus its parentNode's:  (0, 3) g cost is:  13\n",
      "(1, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  59\n",
      "The currentNode is:  (0, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 3) in iteration:  59\n",
      "(-1, 3) :not on array\n",
      "\n",
      "Main for-loop iteration:  60\n",
      "The currentNode is:  (0, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 2) in iteration:  60\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 2) is on the array\n",
      "neighborNode (0, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 2)\n",
      "index after cast:  [0, 2]\n",
      "Obtain cost of node: [ 0 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 2) without adding parent cost is:  4\n",
      "g cost of parent node:  (0, 3) is:  13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g cost of neighborNode:  (0, 2) plus its parentNode's:  (0, 3) g cost is:  17\n",
      "(0, 2)  added to open list\n",
      "h of neighborNode:  (0, 2) is:  10\n",
      "f cost of neighborNode:  (0, 2) is:  27\n",
      "Current Node:  (1, 8)\n",
      "Unsuccessful goal check number:  16\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 8), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 3), (0, 8), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  61\n",
      "The currentNode is:  (1, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 9) in iteration:  61\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 9) is on the array\n",
      "neighborNode (1, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 9)\n",
      "index after cast:  [1, 9]\n",
      "Obtain cost of node: [ 1 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 9) without adding parent cost is:  5\n",
      "g cost of parent node:  (1, 8) is:  9\n",
      "g cost of neighborNode:  (1, 9) plus its parentNode's:  (1, 8) g cost is:  14\n",
      "(1, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  62\n",
      "The currentNode is:  (1, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 8) in iteration:  62\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 8) is on the array\n",
      "neighborNode (2, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 8)\n",
      "index after cast:  [2, 8]\n",
      "Obtain cost of node: [ 2 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (1, 8) is:  9\n",
      "g cost of neighborNode:  (2, 8) plus its parentNode's:  (1, 8) g cost is:  17\n",
      "\n",
      "Main for-loop iteration:  63\n",
      "The currentNode is:  (1, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 8) in iteration:  63\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 8) is on the array\n",
      "neighborNode (0, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 8)\n",
      "index after cast:  [0, 8]\n",
      "Obtain cost of node: [ 0 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 8) without adding parent cost is:  4\n",
      "g cost of parent node:  (1, 8) is:  9\n",
      "g cost of neighborNode:  (0, 8) plus its parentNode's:  (1, 8) g cost is:  13\n",
      "(0, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  64\n",
      "The currentNode is:  (1, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 7) in iteration:  64\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 7) is on the array\n",
      "neighborNode (1, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 7)\n",
      "index after cast:  [1, 7]\n",
      "Obtain cost of node: [ 1 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (1, 8) is:  9\n",
      "g cost of neighborNode:  (1, 7) plus its parentNode's:  (1, 8) g cost is:  14\n",
      "(1, 7) not pushed\n",
      "Current Node:  (3, 4)\n",
      "Unsuccessful goal check number:  17\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 8), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 3), (0, 8), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  65\n",
      "The currentNode is:  (3, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 5) in iteration:  65\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 5) is on the array\n",
      "neighborNode (3, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 5)\n",
      "index after cast:  [3, 5]\n",
      "Obtain cost of node: [ 3 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 5) without adding parent cost is:  9\n",
      "g cost of parent node:  (3, 4) is:  15\n",
      "g cost of neighborNode:  (3, 5) plus its parentNode's:  (3, 4) g cost is:  24\n",
      "(3, 5)  added to open list\n",
      "h of neighborNode:  (3, 5) is:  10\n",
      "f cost of neighborNode:  (3, 5) is:  34\n",
      "\n",
      "Main for-loop iteration:  66\n",
      "The currentNode is:  (3, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 4) in iteration:  66\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 4) is on the array\n",
      "neighborNode (4, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 4)\n",
      "index after cast:  [4, 4]\n",
      "Obtain cost of node: [ 4 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 4) is:  15\n",
      "g cost of neighborNode:  (4, 4) plus its parentNode's:  (3, 4) g cost is:  20\n",
      "(4, 4)  added to open list\n",
      "h of neighborNode:  (4, 4) is:  8\n",
      "f cost of neighborNode:  (4, 4) is:  28\n",
      "\n",
      "Main for-loop iteration:  67\n",
      "The currentNode is:  (3, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 4) in iteration:  67\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 4) is on the array\n",
      "neighborNode (2, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 4)\n",
      "index after cast:  [2, 4]\n",
      "Obtain cost of node: [ 2 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (2, 4) without adding parent cost is:  0\n",
      "g cost of parent node:  (3, 4) is:  15\n",
      "g cost of neighborNode:  (2, 4) plus its parentNode's:  (3, 4) g cost is:  15\n",
      "(2, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  68\n",
      "The currentNode is:  (3, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 3) in iteration:  68\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 3) is on the array\n",
      "neighborNode (3, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 3)\n",
      "index after cast:  [3, 3]\n",
      "Obtain cost of node: [ 3 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 3) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 4) is:  15\n",
      "g cost of neighborNode:  (3, 3) plus its parentNode's:  (3, 4) g cost is:  17\n",
      "(3, 3)  added to open list\n",
      "h of neighborNode:  (3, 3) is:  8\n",
      "f cost of neighborNode:  (3, 3) is:  25\n",
      "Current Node:  (0, 5)\n",
      "Unsuccessful goal check number:  18\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 8), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (0, 3), (0, 8), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  69\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 6) in iteration:  69\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 6) is on the array\n",
      "neighborNode (0, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 6)\n",
      "index after cast:  [0, 6]\n",
      "Obtain cost of node: [ 0 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 6) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (0, 6) plus its parentNode's:  (0, 5) g cost is:  20\n",
      "(0, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  70\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 5) in iteration:  70\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 5) is on the array\n",
      "neighborNode (1, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (1, 5) plus its parentNode's:  (0, 5) g cost is:  13\n",
      "(1, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  71\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 5) in iteration:  71\n",
      "(-1, 5) :not on array\n",
      "\n",
      "Main for-loop iteration:  72\n",
      "The currentNode is:  (0, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 4) in iteration:  72\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 4) is on the array\n",
      "neighborNode (0, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 4)\n",
      "index after cast:  [0, 4]\n",
      "Obtain cost of node: [ 0 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 4) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 5) is:  11\n",
      "g cost of neighborNode:  (0, 4) plus its parentNode's:  (0, 5) g cost is:  20\n",
      "Current Node:  (2, 5)\n",
      "Unsuccessful goal check number:  19\n",
      "Closed Nodes:  {(2, 7), (1, 3), (2, 9), (0, 7), (1, 4), (1, 5), (0, 6), (1, 8), (1, 6), (1, 9), (0, 5), (1, 7), (0, 9), (2, 5), (0, 3), (0, 8), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  73\n",
      "The currentNode is:  (2, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 6) in iteration:  73\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 6) is on the array\n",
      "neighborNode (2, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 6)\n",
      "index after cast:  [2, 6]\n",
      "Obtain cost of node: [ 2 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (2, 6) without adding parent cost is:  7\n",
      "g cost of parent node:  (2, 5) is:  14\n",
      "g cost of neighborNode:  (2, 6) plus its parentNode's:  (2, 5) g cost is:  21\n",
      "\n",
      "Main for-loop iteration:  74\n",
      "The currentNode is:  (2, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 5) in iteration:  74\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 5) is on the array\n",
      "neighborNode (3, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 5)\n",
      "index after cast:  [3, 5]\n",
      "Obtain cost of node: [ 3 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 5) without adding parent cost is:  9\n",
      "g cost of parent node:  (2, 5) is:  14\n",
      "g cost of neighborNode:  (3, 5) plus its parentNode's:  (2, 5) g cost is:  23\n",
      "(3, 5)  added to open list\n",
      "h of neighborNode:  (3, 5) is:  10\n",
      "f cost of neighborNode:  (3, 5) is:  33\n",
      "\n",
      "Main for-loop iteration:  75\n",
      "The currentNode is:  (2, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 5) in iteration:  75\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 5) is on the array\n",
      "neighborNode (1, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (2, 5) is:  14\n",
      "g cost of neighborNode:  (1, 5) plus its parentNode's:  (2, 5) g cost is:  16\n",
      "(1, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  76\n",
      "The currentNode is:  (2, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 4) in iteration:  76\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 4) is on the array\n",
      "neighborNode (2, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 4)\n",
      "index after cast:  [2, 4]\n",
      "Obtain cost of node: [ 2 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (2, 4) without adding parent cost is:  0\n",
      "g cost of parent node:  (2, 5) is:  14\n",
      "g cost of neighborNode:  (2, 4) plus its parentNode's:  (2, 5) g cost is:  14\n",
      "(2, 4) not pushed\n",
      "Current Node:  (3, 3)\n",
      "Unsuccessful goal check number:  20\n",
      "Closed Nodes:  {(1, 3), (0, 7), (1, 6), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (1, 4), (0, 5), (1, 9), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  77\n",
      "The currentNode is:  (3, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 4) in iteration:  77\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 4) is on the array\n",
      "neighborNode (3, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 3) is:  17\n",
      "g cost of neighborNode:  (3, 4) plus its parentNode's:  (3, 3) g cost is:  19\n",
      "(3, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  78\n",
      "The currentNode is:  (3, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 3) in iteration:  78\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 3) is on the array\n",
      "neighborNode (4, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 3)\n",
      "index after cast:  [4, 3]\n",
      "Obtain cost of node: [ 4 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (3, 3) is:  17\n",
      "g cost of neighborNode:  (4, 3) plus its parentNode's:  (3, 3) g cost is:  24\n",
      "(4, 3)  added to open list\n",
      "h of neighborNode:  (4, 3) is:  7\n",
      "f cost of neighborNode:  (4, 3) is:  31\n",
      "\n",
      "Main for-loop iteration:  79\n",
      "The currentNode is:  (3, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 3) in iteration:  79\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 3) is on the array\n",
      "neighborNode (2, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 3)\n",
      "index after cast:  [2, 3]\n",
      "Obtain cost of node: [ 2 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 3) without adding parent cost is:  8\n",
      "g cost of parent node:  (3, 3) is:  17\n",
      "g cost of neighborNode:  (2, 3) plus its parentNode's:  (3, 3) g cost is:  25\n",
      "\n",
      "Main for-loop iteration:  80\n",
      "The currentNode is:  (3, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 2) in iteration:  80\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 2) is on the array\n",
      "neighborNode (3, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 2)\n",
      "index after cast:  [3, 2]\n",
      "Obtain cost of node: [ 3 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 2) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 3) is:  17\n",
      "g cost of neighborNode:  (3, 2) plus its parentNode's:  (3, 3) g cost is:  18\n",
      "(3, 2)  added to open list\n",
      "h of neighborNode:  (3, 2) is:  7\n",
      "f cost of neighborNode:  (3, 2) is:  25\n",
      "Current Node:  (3, 2)\n",
      "Unsuccessful goal check number:  21\n",
      "Closed Nodes:  {(1, 3), (0, 7), (1, 6), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (1, 4), (0, 5), (1, 9), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  81\n",
      "The currentNode is:  (3, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 3) in iteration:  81\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 3) is on the array\n",
      "neighborNode (3, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 3)\n",
      "index after cast:  [3, 3]\n",
      "Obtain cost of node: [ 3 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 3) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 2) is:  18\n",
      "g cost of neighborNode:  (3, 3) plus its parentNode's:  (3, 2) g cost is:  20\n",
      "(3, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  82\n",
      "The currentNode is:  (3, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 2) in iteration:  82\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 2) is on the array\n",
      "neighborNode (4, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 2)\n",
      "index after cast:  [4, 2]\n",
      "Obtain cost of node: [ 4 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (4, 2) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 2) is:  18\n",
      "g cost of neighborNode:  (4, 2) plus its parentNode's:  (3, 2) g cost is:  20\n",
      "(4, 2)  added to open list\n",
      "h of neighborNode:  (4, 2) is:  6\n",
      "f cost of neighborNode:  (4, 2) is:  26\n",
      "\n",
      "Main for-loop iteration:  83\n",
      "The currentNode is:  (3, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 2) in iteration:  83\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 2) is on the array\n",
      "neighborNode (2, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 2)\n",
      "index after cast:  [2, 2]\n",
      "Obtain cost of node: [ 2 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (3, 2) is:  18\n",
      "g cost of neighborNode:  (2, 2) plus its parentNode's:  (3, 2) g cost is:  27\n",
      "(2, 2)  added to open list\n",
      "h of neighborNode:  (2, 2) is:  8\n",
      "f cost of neighborNode:  (2, 2) is:  35\n",
      "\n",
      "Main for-loop iteration:  84\n",
      "The currentNode is:  (3, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 1) in iteration:  84\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 1) is on the array\n",
      "neighborNode (3, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 1)\n",
      "index after cast:  [3, 1]\n",
      "Obtain cost of node: [ 3 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (3, 2) is:  18\n",
      "g cost of neighborNode:  (3, 1) plus its parentNode's:  (3, 2) g cost is:  27\n",
      "(3, 1)  added to open list\n",
      "h of neighborNode:  (3, 1) is:  6\n",
      "f cost of neighborNode:  (3, 1) is:  33\n",
      "Current Node:  (3, 7)\n",
      "Unsuccessful goal check number:  22\n",
      "Closed Nodes:  {(1, 3), (0, 7), (1, 6), (3, 7), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (1, 4), (0, 5), (1, 9), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  85\n",
      "The currentNode is:  (3, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 8) in iteration:  85\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 8) is on the array\n",
      "neighborNode (3, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 8)\n",
      "index after cast:  [3, 8]\n",
      "Obtain cost of node: [ 3 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 8) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 7) is:  14\n",
      "g cost of neighborNode:  (3, 8) plus its parentNode's:  (3, 7) g cost is:  15\n",
      "(3, 8)  added to open list\n",
      "h of neighborNode:  (3, 8) is:  13\n",
      "f cost of neighborNode:  (3, 8) is:  28\n",
      "\n",
      "Main for-loop iteration:  86\n",
      "The currentNode is:  (3, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 7) in iteration:  86\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 7) is on the array\n",
      "neighborNode (4, 7) has taken the value of checkNode\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 7)\n",
      "index after cast:  [4, 7]\n",
      "Obtain cost of node: [ 4 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 7) without adding parent cost is:  7\n",
      "g cost of parent node:  (3, 7) is:  14\n",
      "g cost of neighborNode:  (4, 7) plus its parentNode's:  (3, 7) g cost is:  21\n",
      "(4, 7)  added to open list\n",
      "h of neighborNode:  (4, 7) is:  11\n",
      "f cost of neighborNode:  (4, 7) is:  32\n",
      "\n",
      "Main for-loop iteration:  87\n",
      "The currentNode is:  (3, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 7) in iteration:  87\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 7) is on the array\n",
      "neighborNode (2, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 7)\n",
      "index after cast:  [2, 7]\n",
      "Obtain cost of node: [ 2 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (2, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (3, 7) is:  14\n",
      "g cost of neighborNode:  (2, 7) plus its parentNode's:  (3, 7) g cost is:  18\n",
      "(2, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  88\n",
      "The currentNode is:  (3, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 6) in iteration:  88\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 6) is on the array\n",
      "neighborNode (3, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 6)\n",
      "index after cast:  [3, 6]\n",
      "Obtain cost of node: [ 3 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (3, 6) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 7) is:  14\n",
      "g cost of neighborNode:  (3, 6) plus its parentNode's:  (3, 7) g cost is:  19\n",
      "(3, 6)  added to open list\n",
      "h of neighborNode:  (3, 6) is:  11\n",
      "f cost of neighborNode:  (3, 6) is:  30\n",
      "Current Node:  (4, 2)\n",
      "Unsuccessful goal check number:  23\n",
      "Closed Nodes:  {(1, 3), (0, 7), (1, 6), (3, 7), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (1, 4), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  89\n",
      "The currentNode is:  (4, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 3) in iteration:  89\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 3) is on the array\n",
      "neighborNode (4, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 3)\n",
      "index after cast:  [4, 3]\n",
      "Obtain cost of node: [ 4 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 2) is:  20\n",
      "g cost of neighborNode:  (4, 3) plus its parentNode's:  (4, 2) g cost is:  27\n",
      "\n",
      "Main for-loop iteration:  90\n",
      "The currentNode is:  (4, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 2) in iteration:  90\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 2) is on the array\n",
      "neighborNode (5, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 2)\n",
      "index after cast:  [5, 2]\n",
      "Obtain cost of node: [ 5 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (5, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (4, 2) is:  20\n",
      "g cost of neighborNode:  (5, 2) plus its parentNode's:  (4, 2) g cost is:  20\n",
      "(5, 2)  added to open list\n",
      "h of neighborNode:  (5, 2) is:  5\n",
      "f cost of neighborNode:  (5, 2) is:  25\n",
      "\n",
      "Main for-loop iteration:  91\n",
      "The currentNode is:  (4, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 2) in iteration:  91\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 2) is on the array\n",
      "neighborNode (3, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 2)\n",
      "index after cast:  [3, 2]\n",
      "Obtain cost of node: [ 3 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 2) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 2) is:  20\n",
      "g cost of neighborNode:  (3, 2) plus its parentNode's:  (4, 2) g cost is:  21\n",
      "(3, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  92\n",
      "The currentNode is:  (4, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 1) in iteration:  92\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 1) is on the array\n",
      "neighborNode (4, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 1)\n",
      "index after cast:  [4, 1]\n",
      "Obtain cost of node: [ 4 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 1) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 2) is:  20\n",
      "g cost of neighborNode:  (4, 1) plus its parentNode's:  (4, 2) g cost is:  25\n",
      "(4, 1)  added to open list\n",
      "h of neighborNode:  (4, 1) is:  5\n",
      "f cost of neighborNode:  (4, 1) is:  30\n",
      "Current Node:  (5, 2)\n",
      "Unsuccessful goal check number:  24\n",
      "Closed Nodes:  {(1, 3), (0, 7), (1, 6), (3, 7), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  93\n",
      "The currentNode is:  (5, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 3) in iteration:  93\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 3) is on the array\n",
      "neighborNode (5, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 3)\n",
      "index after cast:  [5, 3]\n",
      "Obtain cost of node: [ 5 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 2) is:  20\n",
      "g cost of neighborNode:  (5, 3) plus its parentNode's:  (5, 2) g cost is:  27\n",
      "(5, 3)  added to open list\n",
      "h of neighborNode:  (5, 3) is:  6\n",
      "f cost of neighborNode:  (5, 3) is:  33\n",
      "\n",
      "Main for-loop iteration:  94\n",
      "The currentNode is:  (5, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 2) in iteration:  94\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 2) is on the array\n",
      "neighborNode (6, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 2)\n",
      "index after cast:  [6, 2]\n",
      "Obtain cost of node: [ 6 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (5, 2) is:  20\n",
      "g cost of neighborNode:  (6, 2) plus its parentNode's:  (5, 2) g cost is:  20\n",
      "(6, 2)  added to open list\n",
      "h of neighborNode:  (6, 2) is:  4\n",
      "f cost of neighborNode:  (6, 2) is:  24\n",
      "\n",
      "Main for-loop iteration:  95\n",
      "The currentNode is:  (5, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 2) in iteration:  95\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 2) is on the array\n",
      "neighborNode (4, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 2)\n",
      "index after cast:  [4, 2]\n",
      "Obtain cost of node: [ 4 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (4, 2) without adding parent cost is:  2\n",
      "g cost of parent node:  (5, 2) is:  20\n",
      "g cost of neighborNode:  (4, 2) plus its parentNode's:  (5, 2) g cost is:  22\n",
      "(4, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  96\n",
      "The currentNode is:  (5, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 1) in iteration:  96\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 1) is on the array\n",
      "neighborNode (5, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 1)\n",
      "index after cast:  [5, 1]\n",
      "Obtain cost of node: [ 5 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (5, 1) without adding parent cost is:  6\n",
      "g cost of parent node:  (5, 2) is:  20\n",
      "g cost of neighborNode:  (5, 1) plus its parentNode's:  (5, 2) g cost is:  26\n",
      "(5, 1)  added to open list\n",
      "h of neighborNode:  (5, 1) is:  4\n",
      "f cost of neighborNode:  (5, 1) is:  30\n",
      "Current Node:  (6, 2)\n",
      "Unsuccessful goal check number:  25\n",
      "Closed Nodes:  {(1, 3), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  97\n",
      "The currentNode is:  (6, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 3) in iteration:  97\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 3) is on the array\n",
      "neighborNode (6, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 3)\n",
      "index after cast:  [6, 3]\n",
      "Obtain cost of node: [ 6 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 2) is:  20\n",
      "g cost of neighborNode:  (6, 3) plus its parentNode's:  (6, 2) g cost is:  27\n",
      "(6, 3)  added to open list\n",
      "h of neighborNode:  (6, 3) is:  5\n",
      "f cost of neighborNode:  (6, 3) is:  32\n",
      "\n",
      "Main for-loop iteration:  98\n",
      "The currentNode is:  (6, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 2) in iteration:  98\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 2) is on the array\n",
      "neighborNode (7, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 2)\n",
      "index after cast:  [7, 2]\n",
      "Obtain cost of node: [ 7 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (7, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (6, 2) is:  20\n",
      "g cost of neighborNode:  (7, 2) plus its parentNode's:  (6, 2) g cost is:  29\n",
      "(7, 2)  added to open list\n",
      "h of neighborNode:  (7, 2) is:  3\n",
      "f cost of neighborNode:  (7, 2) is:  32\n",
      "\n",
      "Main for-loop iteration:  99\n",
      "The currentNode is:  (6, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 2) in iteration:  99\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 2) is on the array\n",
      "neighborNode (5, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 2)\n",
      "index after cast:  [5, 2]\n",
      "Obtain cost of node: [ 5 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (5, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 2) is:  20\n",
      "g cost of neighborNode:  (5, 2) plus its parentNode's:  (6, 2) g cost is:  20\n",
      "(5, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  100\n",
      "The currentNode is:  (6, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 1) in iteration:  100\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 1) is on the array\n",
      "neighborNode (6, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 1)\n",
      "index after cast:  [6, 1]\n",
      "Obtain cost of node: [ 6 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (6, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (6, 2) is:  20\n",
      "g cost of neighborNode:  (6, 1) plus its parentNode's:  (6, 2) g cost is:  28\n",
      "(6, 1)  added to open list\n",
      "h of neighborNode:  (6, 1) is:  3\n",
      "f cost of neighborNode:  (6, 1) is:  31\n",
      "Current Node:  (0, 2)\n",
      "Unsuccessful goal check number:  26\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  101\n",
      "The currentNode is:  (0, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 3) in iteration:  101\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 3) is on the array\n",
      "neighborNode (0, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 3)\n",
      "index after cast:  [0, 3]\n",
      "Obtain cost of node: [ 0 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (0, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (0, 2) is:  17\n",
      "g cost of neighborNode:  (0, 3) plus its parentNode's:  (0, 2) g cost is:  17\n",
      "(0, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  102\n",
      "The currentNode is:  (0, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 2) in iteration:  102\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 2) is on the array\n",
      "neighborNode (1, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 2)\n",
      "index after cast:  [1, 2]\n",
      "Obtain cost of node: [ 1 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 2) without adding parent cost is:  5\n",
      "g cost of parent node:  (0, 2) is:  17\n",
      "g cost of neighborNode:  (1, 2) plus its parentNode's:  (0, 2) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  103\n",
      "The currentNode is:  (0, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 2) in iteration:  103\n",
      "(-1, 2) :not on array\n",
      "\n",
      "Main for-loop iteration:  104\n",
      "The currentNode is:  (0, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 1) in iteration:  104\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 1) is on the array\n",
      "neighborNode (0, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 1)\n",
      "index after cast:  [0, 1]\n",
      "Obtain cost of node: [ 0 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (0, 1) without adding parent cost is:  3\n",
      "g cost of parent node:  (0, 2) is:  17\n",
      "g cost of neighborNode:  (0, 1) plus its parentNode's:  (0, 2) g cost is:  20\n",
      "(0, 1)  added to open list\n",
      "h of neighborNode:  (0, 1) is:  9\n",
      "f cost of neighborNode:  (0, 1) is:  29\n",
      "Current Node:  (1, 2)\n",
      "Unsuccessful goal check number:  27\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  105\n",
      "The currentNode is:  (1, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 3) in iteration:  105\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 3) is on the array\n",
      "neighborNode (1, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 3)\n",
      "index after cast:  [1, 3]\n",
      "Obtain cost of node: [ 1 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (1, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (1, 2) is:  18\n",
      "g cost of neighborNode:  (1, 3) plus its parentNode's:  (1, 2) g cost is:  18\n",
      "(1, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  106\n",
      "The currentNode is:  (1, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 2) in iteration:  106\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 2) is on the array\n",
      "neighborNode (2, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 2)\n",
      "index after cast:  [2, 2]\n",
      "Obtain cost of node: [ 2 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 2) is:  18\n",
      "g cost of neighborNode:  (2, 2) plus its parentNode's:  (1, 2) g cost is:  27\n",
      "\n",
      "Main for-loop iteration:  107\n",
      "The currentNode is:  (1, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 2) in iteration:  107\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 2) is on the array\n",
      "neighborNode (0, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 2)\n",
      "index after cast:  [0, 2]\n",
      "Obtain cost of node: [ 0 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 2) without adding parent cost is:  4\n",
      "g cost of parent node:  (1, 2) is:  18\n",
      "g cost of neighborNode:  (0, 2) plus its parentNode's:  (1, 2) g cost is:  22\n",
      "(0, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  108\n",
      "The currentNode is:  (1, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 1) in iteration:  108\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 1) is on the array\n",
      "neighborNode (1, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 1)\n",
      "index after cast:  [1, 1]\n",
      "Obtain cost of node: [ 1 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (1, 1) without adding parent cost is:  4\n",
      "g cost of parent node:  (1, 2) is:  18\n",
      "g cost of neighborNode:  (1, 1) plus its parentNode's:  (1, 2) g cost is:  22\n",
      "(1, 1)  added to open list\n",
      "h of neighborNode:  (1, 1) is:  8\n",
      "f cost of neighborNode:  (1, 1) is:  30\n",
      "Current Node:  (3, 9)\n",
      "Unsuccessful goal check number:  28\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  109\n",
      "The currentNode is:  (3, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 10) in iteration:  109\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(3, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  110\n",
      "The currentNode is:  (3, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 9) in iteration:  110\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 9) is on the array\n",
      "neighborNode (4, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 9)\n",
      "index after cast:  [4, 9]\n",
      "Obtain cost of node: [ 4 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (4, 9) without adding parent cost is:  4\n",
      "g cost of parent node:  (3, 9) is:  13\n",
      "g cost of neighborNode:  (4, 9) plus its parentNode's:  (3, 9) g cost is:  17\n",
      "(4, 9)  added to open list\n",
      "h of neighborNode:  (4, 9) is:  13\n",
      "f cost of neighborNode:  (4, 9) is:  30\n",
      "\n",
      "Main for-loop iteration:  111\n",
      "The currentNode is:  (3, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 9) in iteration:  111\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 9) is on the array\n",
      "neighborNode (2, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 9)\n",
      "index after cast:  [2, 9]\n",
      "Obtain cost of node: [ 2 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (2, 9) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 9) is:  13\n",
      "g cost of neighborNode:  (2, 9) plus its parentNode's:  (3, 9) g cost is:  14\n",
      "(2, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  112\n",
      "The currentNode is:  (3, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 8) in iteration:  112\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 8) is on the array\n",
      "neighborNode (3, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 8)\n",
      "index after cast:  [3, 8]\n",
      "Obtain cost of node: [ 3 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 8) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 9) is:  13\n",
      "g cost of neighborNode:  (3, 8) plus its parentNode's:  (3, 9) g cost is:  14\n",
      "(3, 8)  added to open list\n",
      "h of neighborNode:  (3, 8) is:  13\n",
      "f cost of neighborNode:  (3, 8) is:  27\n",
      "Current Node:  (3, 8)\n",
      "Unsuccessful goal check number:  29\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (1, 5), (3, 2), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  113\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 9) in iteration:  113\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 9) is on the array\n",
      "neighborNode (3, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 9)\n",
      "index after cast:  [3, 9]\n",
      "Obtain cost of node: [ 3 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (3, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (3, 9) plus its parentNode's:  (3, 8) g cost is:  20\n",
      "(3, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  114\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 8) in iteration:  114\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 8) is on the array\n",
      "neighborNode (4, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 8)\n",
      "index after cast:  [4, 8]\n",
      "Obtain cost of node: [ 4 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 8) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (4, 8) plus its parentNode's:  (3, 8) g cost is:  19\n",
      "(4, 8)  added to open list\n",
      "h of neighborNode:  (4, 8) is:  12\n",
      "f cost of neighborNode:  (4, 8) is:  31\n",
      "\n",
      "Main for-loop iteration:  115\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 8) in iteration:  115\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "checkNode:  (2, 8) is on the array\n",
      "neighborNode (2, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 8)\n",
      "index after cast:  [2, 8]\n",
      "Obtain cost of node: [ 2 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (2, 8) plus its parentNode's:  (3, 8) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  116\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 7) in iteration:  116\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 7) is on the array\n",
      "neighborNode (3, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 7)\n",
      "index after cast:  [3, 7]\n",
      "Obtain cost of node: [ 3 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (3, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (3, 7) plus its parentNode's:  (3, 8) g cost is:  18\n",
      "(3, 7) not pushed\n",
      "Current Node:  (2, 6)\n",
      "Unsuccessful goal check number:  30\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (1, 5), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  117\n",
      "The currentNode is:  (2, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 7) in iteration:  117\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 7) is on the array\n",
      "neighborNode (2, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 7)\n",
      "index after cast:  [2, 7]\n",
      "Obtain cost of node: [ 2 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (2, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (2, 6) is:  16\n",
      "g cost of neighborNode:  (2, 7) plus its parentNode's:  (2, 6) g cost is:  20\n",
      "(2, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  118\n",
      "The currentNode is:  (2, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 6) in iteration:  118\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 6) is on the array\n",
      "neighborNode (3, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 6)\n",
      "index after cast:  [3, 6]\n",
      "Obtain cost of node: [ 3 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (3, 6) without adding parent cost is:  5\n",
      "g cost of parent node:  (2, 6) is:  16\n",
      "g cost of neighborNode:  (3, 6) plus its parentNode's:  (2, 6) g cost is:  21\n",
      "\n",
      "Main for-loop iteration:  119\n",
      "The currentNode is:  (2, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 6) in iteration:  119\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 6) is on the array\n",
      "neighborNode (1, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 6)\n",
      "index after cast:  [1, 6]\n",
      "Obtain cost of node: [ 1 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (1, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (2, 6) is:  16\n",
      "g cost of neighborNode:  (1, 6) plus its parentNode's:  (2, 6) g cost is:  19\n",
      "(1, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  120\n",
      "The currentNode is:  (2, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 5) in iteration:  120\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 5) is on the array\n",
      "neighborNode (2, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 5)\n",
      "index after cast:  [2, 5]\n",
      "Obtain cost of node: [ 2 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (2, 5) without adding parent cost is:  3\n",
      "g cost of parent node:  (2, 6) is:  16\n",
      "g cost of neighborNode:  (2, 5) plus its parentNode's:  (2, 6) g cost is:  19\n",
      "(2, 5) not pushed\n",
      "Current Node:  (3, 8)\n",
      "Unsuccessful goal check number:  31\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (1, 5), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  121\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 9) in iteration:  121\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 9) is on the array\n",
      "neighborNode (3, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 9)\n",
      "index after cast:  [3, 9]\n",
      "Obtain cost of node: [ 3 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (3, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (3, 9) plus its parentNode's:  (3, 8) g cost is:  20\n",
      "(3, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  122\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 8) in iteration:  122\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 8) is on the array\n",
      "neighborNode (4, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 8)\n",
      "index after cast:  [4, 8]\n",
      "Obtain cost of node: [ 4 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 8) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (4, 8) plus its parentNode's:  (3, 8) g cost is:  19\n",
      "\n",
      "Main for-loop iteration:  123\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 8) in iteration:  123\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 8) is on the array\n",
      "neighborNode (2, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 8)\n",
      "index after cast:  [2, 8]\n",
      "Obtain cost of node: [ 2 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (2, 8) plus its parentNode's:  (3, 8) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  124\n",
      "The currentNode is:  (3, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 7) in iteration:  124\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 7) is on the array\n",
      "neighborNode (3, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 7)\n",
      "index after cast:  [3, 7]\n",
      "Obtain cost of node: [ 3 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (3, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (3, 8) is:  14\n",
      "g cost of neighborNode:  (3, 7) plus its parentNode's:  (3, 8) g cost is:  18\n",
      "(3, 7) not pushed\n",
      "Current Node:  (4, 4)\n",
      "Unsuccessful goal check number:  32\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  125\n",
      "The currentNode is:  (4, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 5) in iteration:  125\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 5) is on the array\n",
      "neighborNode (4, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 5)\n",
      "index after cast:  [4, 5]\n",
      "Obtain cost of node: [ 4 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 4) is:  20\n",
      "g cost of neighborNode:  (4, 5) plus its parentNode's:  (4, 4) g cost is:  21\n",
      "(4, 5)  added to open list\n",
      "h of neighborNode:  (4, 5) is:  9\n",
      "f cost of neighborNode:  (4, 5) is:  30\n",
      "\n",
      "Main for-loop iteration:  126\n",
      "The currentNode is:  (4, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 4) in iteration:  126\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 4) is on the array\n",
      "neighborNode (5, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 4)\n",
      "index after cast:  [5, 4]\n",
      "Obtain cost of node: [ 5 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 4) is:  20\n",
      "g cost of neighborNode:  (5, 4) plus its parentNode's:  (4, 4) g cost is:  25\n",
      "(5, 4)  added to open list\n",
      "h of neighborNode:  (5, 4) is:  7\n",
      "f cost of neighborNode:  (5, 4) is:  32\n",
      "\n",
      "Main for-loop iteration:  127\n",
      "The currentNode is:  (4, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 4) in iteration:  127\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 4) is on the array\n",
      "neighborNode (3, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (4, 4) is:  20\n",
      "g cost of neighborNode:  (3, 4) plus its parentNode's:  (4, 4) g cost is:  22\n",
      "(3, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  128\n",
      "The currentNode is:  (4, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 3) in iteration:  128\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 3) is on the array\n",
      "neighborNode (4, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 3)\n",
      "index after cast:  [4, 3]\n",
      "Obtain cost of node: [ 4 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 4) is:  20\n",
      "g cost of neighborNode:  (4, 3) plus its parentNode's:  (4, 4) g cost is:  27\n",
      "Current Node:  (0, 1)\n",
      "Unsuccessful goal check number:  33\n",
      "Closed Nodes:  {(1, 3), (0, 2), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  129\n",
      "The currentNode is:  (0, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 2) in iteration:  129\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 2) is on the array\n",
      "neighborNode (0, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 2)\n",
      "index after cast:  [0, 2]\n",
      "Obtain cost of node: [ 0 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (0, 2) without adding parent cost is:  4\n",
      "g cost of parent node:  (0, 1) is:  20\n",
      "g cost of neighborNode:  (0, 2) plus its parentNode's:  (0, 1) g cost is:  24\n",
      "(0, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  130\n",
      "The currentNode is:  (0, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 1) in iteration:  130\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 1) is on the array\n",
      "neighborNode (1, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 1)\n",
      "index after cast:  [1, 1]\n",
      "Obtain cost of node: [ 1 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (1, 1) without adding parent cost is:  4\n",
      "g cost of parent node:  (0, 1) is:  20\n",
      "g cost of neighborNode:  (1, 1) plus its parentNode's:  (0, 1) g cost is:  24\n",
      "\n",
      "Main for-loop iteration:  131\n",
      "The currentNode is:  (0, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 1) in iteration:  131\n",
      "(-1, 1) :not on array\n",
      "\n",
      "Main for-loop iteration:  132\n",
      "The currentNode is:  (0, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 0) in iteration:  132\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 0) is on the array\n",
      "neighborNode (0, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 0)\n",
      "index after cast:  [0, 0]\n",
      "Obtain cost of node: [ 0 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 0) without adding parent cost is:  9\n",
      "g cost of parent node:  (0, 1) is:  20\n",
      "g cost of neighborNode:  (0, 0) plus its parentNode's:  (0, 1) g cost is:  29\n",
      "(0, 0)  added to open list\n",
      "h of neighborNode:  (0, 0) is:  10\n",
      "f cost of neighborNode:  (0, 0) is:  39\n",
      "Current Node:  (2, 8)\n",
      "Unsuccessful goal check number:  34\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  133\n",
      "The currentNode is:  (2, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 9) in iteration:  133\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 9) is on the array\n",
      "neighborNode (2, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 9)\n",
      "index after cast:  [2, 9]\n",
      "Obtain cost of node: [ 2 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (2, 9) without adding parent cost is:  1\n",
      "g cost of parent node:  (2, 8) is:  15\n",
      "g cost of neighborNode:  (2, 9) plus its parentNode's:  (2, 8) g cost is:  16\n",
      "(2, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  134\n",
      "The currentNode is:  (2, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 8) in iteration:  134\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 8) is on the array\n",
      "neighborNode (3, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 8)\n",
      "index after cast:  [3, 8]\n",
      "Obtain cost of node: [ 3 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 8) without adding parent cost is:  1\n",
      "g cost of parent node:  (2, 8) is:  15\n",
      "g cost of neighborNode:  (3, 8) plus its parentNode's:  (2, 8) g cost is:  16\n",
      "(3, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  135\n",
      "The currentNode is:  (2, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 8) in iteration:  135\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 8) is on the array\n",
      "neighborNode (1, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 8)\n",
      "index after cast:  [1, 8]\n",
      "Obtain cost of node: [ 1 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (1, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (2, 8) is:  15\n",
      "g cost of neighborNode:  (1, 8) plus its parentNode's:  (2, 8) g cost is:  24\n",
      "(1, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  136\n",
      "The currentNode is:  (2, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 7) in iteration:  136\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 7) is on the array\n",
      "neighborNode (2, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 7)\n",
      "index after cast:  [2, 7]\n",
      "Obtain cost of node: [ 2 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (2, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (2, 8) is:  15\n",
      "g cost of neighborNode:  (2, 7) plus its parentNode's:  (2, 8) g cost is:  19\n",
      "(2, 7) not pushed\n",
      "Current Node:  (1, 1)\n",
      "Unsuccessful goal check number:  35\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (1, 1), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  137\n",
      "The currentNode is:  (1, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 2) in iteration:  137\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 2) is on the array\n",
      "neighborNode (1, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 2)\n",
      "index after cast:  [1, 2]\n",
      "Obtain cost of node: [ 1 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 2) without adding parent cost is:  5\n",
      "g cost of parent node:  (1, 1) is:  22\n",
      "g cost of neighborNode:  (1, 2) plus its parentNode's:  (1, 1) g cost is:  27\n",
      "(1, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  138\n",
      "The currentNode is:  (1, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 1) in iteration:  138\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 1) is on the array\n",
      "neighborNode (2, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 1)\n",
      "index after cast:  [2, 1]\n",
      "Obtain cost of node: [ 2 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 1) is:  22\n",
      "g cost of neighborNode:  (2, 1) plus its parentNode's:  (1, 1) g cost is:  31\n",
      "(2, 1)  added to open list\n",
      "h of neighborNode:  (2, 1) is:  7\n",
      "f cost of neighborNode:  (2, 1) is:  38\n",
      "\n",
      "Main for-loop iteration:  139\n",
      "The currentNode is:  (1, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 1) in iteration:  139\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 1) is on the array\n",
      "neighborNode (0, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 1)\n",
      "index after cast:  [0, 1]\n",
      "Obtain cost of node: [ 0 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (0, 1) without adding parent cost is:  3\n",
      "g cost of parent node:  (1, 1) is:  22\n",
      "g cost of neighborNode:  (0, 1) plus its parentNode's:  (1, 1) g cost is:  25\n",
      "(0, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  140\n",
      "The currentNode is:  (1, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, 0) in iteration:  140\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 0) is on the array\n",
      "neighborNode (1, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 0)\n",
      "index after cast:  [1, 0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtain cost of node: [ 1 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (1, 0) without adding parent cost is:  1\n",
      "g cost of parent node:  (1, 1) is:  22\n",
      "g cost of neighborNode:  (1, 0) plus its parentNode's:  (1, 1) g cost is:  23\n",
      "(1, 0)  added to open list\n",
      "h of neighborNode:  (1, 0) is:  9\n",
      "f cost of neighborNode:  (1, 0) is:  32\n",
      "Current Node:  (2, 3)\n",
      "Unsuccessful goal check number:  36\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (1, 1), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  141\n",
      "The currentNode is:  (2, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 4) in iteration:  141\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 4) is on the array\n",
      "neighborNode (2, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 4)\n",
      "index after cast:  [2, 4]\n",
      "Obtain cost of node: [ 2 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (2, 4) without adding parent cost is:  0\n",
      "g cost of parent node:  (2, 3) is:  21\n",
      "g cost of neighborNode:  (2, 4) plus its parentNode's:  (2, 3) g cost is:  21\n",
      "(2, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  142\n",
      "The currentNode is:  (2, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 3) in iteration:  142\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 3) is on the array\n",
      "neighborNode (3, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 3)\n",
      "index after cast:  [3, 3]\n",
      "Obtain cost of node: [ 3 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 3) without adding parent cost is:  2\n",
      "g cost of parent node:  (2, 3) is:  21\n",
      "g cost of neighborNode:  (3, 3) plus its parentNode's:  (2, 3) g cost is:  23\n",
      "(3, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  143\n",
      "The currentNode is:  (2, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 3) in iteration:  143\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 3) is on the array\n",
      "neighborNode (1, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 3)\n",
      "index after cast:  [1, 3]\n",
      "Obtain cost of node: [ 1 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (1, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (2, 3) is:  21\n",
      "g cost of neighborNode:  (1, 3) plus its parentNode's:  (2, 3) g cost is:  21\n",
      "(1, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  144\n",
      "The currentNode is:  (2, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 2) in iteration:  144\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 2) is on the array\n",
      "neighborNode (2, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 2)\n",
      "index after cast:  [2, 2]\n",
      "Obtain cost of node: [ 2 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (2, 3) is:  21\n",
      "g cost of neighborNode:  (2, 2) plus its parentNode's:  (2, 3) g cost is:  30\n",
      "Current Node:  (3, 6)\n",
      "Unsuccessful goal check number:  37\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (1, 1), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  145\n",
      "The currentNode is:  (3, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 7) in iteration:  145\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 7) is on the array\n",
      "neighborNode (3, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 7)\n",
      "index after cast:  [3, 7]\n",
      "Obtain cost of node: [ 3 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (3, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (3, 6) is:  19\n",
      "g cost of neighborNode:  (3, 7) plus its parentNode's:  (3, 6) g cost is:  23\n",
      "(3, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  146\n",
      "The currentNode is:  (3, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 6) in iteration:  146\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 6) is on the array\n",
      "neighborNode (4, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 6)\n",
      "index after cast:  [4, 6]\n",
      "Obtain cost of node: [ 4 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 6) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 6) is:  19\n",
      "g cost of neighborNode:  (4, 6) plus its parentNode's:  (3, 6) g cost is:  20\n",
      "(4, 6)  added to open list\n",
      "h of neighborNode:  (4, 6) is:  10\n",
      "f cost of neighborNode:  (4, 6) is:  30\n",
      "\n",
      "Main for-loop iteration:  147\n",
      "The currentNode is:  (3, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 6) in iteration:  147\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 6) is on the array\n",
      "neighborNode (2, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 6)\n",
      "index after cast:  [2, 6]\n",
      "Obtain cost of node: [ 2 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (2, 6) without adding parent cost is:  7\n",
      "g cost of parent node:  (3, 6) is:  19\n",
      "g cost of neighborNode:  (2, 6) plus its parentNode's:  (3, 6) g cost is:  26\n",
      "(2, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  148\n",
      "The currentNode is:  (3, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 5) in iteration:  148\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 5) is on the array\n",
      "neighborNode (3, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 5)\n",
      "index after cast:  [3, 5]\n",
      "Obtain cost of node: [ 3 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 5) without adding parent cost is:  9\n",
      "g cost of parent node:  (3, 6) is:  19\n",
      "g cost of neighborNode:  (3, 5) plus its parentNode's:  (3, 6) g cost is:  28\n",
      "Current Node:  (4, 1)\n",
      "Unsuccessful goal check number:  38\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  149\n",
      "The currentNode is:  (4, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 2) in iteration:  149\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 2) is on the array\n",
      "neighborNode (4, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 2)\n",
      "index after cast:  [4, 2]\n",
      "Obtain cost of node: [ 4 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (4, 2) without adding parent cost is:  2\n",
      "g cost of parent node:  (4, 1) is:  25\n",
      "g cost of neighborNode:  (4, 2) plus its parentNode's:  (4, 1) g cost is:  27\n",
      "(4, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  150\n",
      "The currentNode is:  (4, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 1) in iteration:  150\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 1) is on the array\n",
      "neighborNode (5, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 1)\n",
      "index after cast:  [5, 1]\n",
      "Obtain cost of node: [ 5 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (5, 1) without adding parent cost is:  6\n",
      "g cost of parent node:  (4, 1) is:  25\n",
      "g cost of neighborNode:  (5, 1) plus its parentNode's:  (4, 1) g cost is:  31\n",
      "\n",
      "Main for-loop iteration:  151\n",
      "The currentNode is:  (4, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 1) in iteration:  151\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 1) is on the array\n",
      "neighborNode (3, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 1)\n",
      "index after cast:  [3, 1]\n",
      "Obtain cost of node: [ 3 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (4, 1) is:  25\n",
      "g cost of neighborNode:  (3, 1) plus its parentNode's:  (4, 1) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  152\n",
      "The currentNode is:  (4, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 0) in iteration:  152\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 0) is on the array\n",
      "neighborNode (4, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 0)\n",
      "index after cast:  [4, 0]\n",
      "Obtain cost of node: [ 4 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (4, 0) without adding parent cost is:  2\n",
      "g cost of parent node:  (4, 1) is:  25\n",
      "g cost of neighborNode:  (4, 0) plus its parentNode's:  (4, 1) g cost is:  27\n",
      "(4, 0)  added to open list\n",
      "h of neighborNode:  (4, 0) is:  6\n",
      "f cost of neighborNode:  (4, 0) is:  33\n",
      "Current Node:  (4, 5)\n",
      "Unsuccessful goal check number:  39\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  153\n",
      "The currentNode is:  (4, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 6) in iteration:  153\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 6) is on the array\n",
      "neighborNode (4, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 6)\n",
      "index after cast:  [4, 6]\n",
      "Obtain cost of node: [ 4 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 6) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 5) is:  21\n",
      "g cost of neighborNode:  (4, 6) plus its parentNode's:  (4, 5) g cost is:  22\n",
      "\n",
      "Main for-loop iteration:  154\n",
      "The currentNode is:  (4, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 5) in iteration:  154\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 5) is on the array\n",
      "neighborNode (5, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 5)\n",
      "index after cast:  [5, 5]\n",
      "Obtain cost of node: [ 5 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (5, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 5) is:  21\n",
      "g cost of neighborNode:  (5, 5) plus its parentNode's:  (4, 5) g cost is:  22\n",
      "(5, 5)  added to open list\n",
      "h of neighborNode:  (5, 5) is:  8\n",
      "f cost of neighborNode:  (5, 5) is:  30\n",
      "\n",
      "Main for-loop iteration:  155\n",
      "The currentNode is:  (4, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 5) in iteration:  155\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 5) is on the array\n",
      "neighborNode (3, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 5)\n",
      "index after cast:  [3, 5]\n",
      "Obtain cost of node: [ 3 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (3, 5) without adding parent cost is:  9\n",
      "g cost of parent node:  (4, 5) is:  21\n",
      "g cost of neighborNode:  (3, 5) plus its parentNode's:  (4, 5) g cost is:  30\n",
      "\n",
      "Main for-loop iteration:  156\n",
      "The currentNode is:  (4, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 4) in iteration:  156\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 4) is on the array\n",
      "neighborNode (4, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 4)\n",
      "index after cast:  [4, 4]\n",
      "Obtain cost of node: [ 4 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 5) is:  21\n",
      "g cost of neighborNode:  (4, 4) plus its parentNode's:  (4, 5) g cost is:  26\n",
      "(4, 4) not pushed\n",
      "Current Node:  (4, 6)\n",
      "Unsuccessful goal check number:  40\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  157\n",
      "The currentNode is:  (4, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 7) in iteration:  157\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 7) is on the array\n",
      "neighborNode (4, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 7)\n",
      "index after cast:  [4, 7]\n",
      "Obtain cost of node: [ 4 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 7) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 6) is:  20\n",
      "g cost of neighborNode:  (4, 7) plus its parentNode's:  (4, 6) g cost is:  27\n",
      "\n",
      "Main for-loop iteration:  158\n",
      "The currentNode is:  (4, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 6) in iteration:  158\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 6) is on the array\n",
      "neighborNode (5, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 6)\n",
      "index after cast:  [5, 6]\n",
      "Obtain cost of node: [ 5 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (5, 6) without adding parent cost is:  8\n",
      "g cost of parent node:  (4, 6) is:  20\n",
      "g cost of neighborNode:  (5, 6) plus its parentNode's:  (4, 6) g cost is:  28\n",
      "(5, 6)  added to open list\n",
      "h of neighborNode:  (5, 6) is:  9\n",
      "f cost of neighborNode:  (5, 6) is:  37\n",
      "\n",
      "Main for-loop iteration:  159\n",
      "The currentNode is:  (4, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 6) in iteration:  159\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 6) is on the array\n",
      "neighborNode (3, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 6)\n",
      "index after cast:  [3, 6]\n",
      "Obtain cost of node: [ 3 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (3, 6) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 6) is:  20\n",
      "g cost of neighborNode:  (3, 6) plus its parentNode's:  (4, 6) g cost is:  25\n",
      "(3, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  160\n",
      "The currentNode is:  (4, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 5) in iteration:  160\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 5) is on the array\n",
      "neighborNode (4, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 5)\n",
      "index after cast:  [4, 5]\n",
      "Obtain cost of node: [ 4 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 6) is:  20\n",
      "g cost of neighborNode:  (4, 5) plus its parentNode's:  (4, 6) g cost is:  21\n",
      "(4, 5) not pushed\n",
      "Current Node:  (4, 9)\n",
      "Unsuccessful goal check number:  41\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (1, 2), (4, 9), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  161\n",
      "The currentNode is:  (4, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 10) in iteration:  161\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(4, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  162\n",
      "The currentNode is:  (4, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 9) in iteration:  162\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 9) is on the array\n",
      "neighborNode (5, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 9)\n",
      "index after cast:  [5, 9]\n",
      "Obtain cost of node: [ 5 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (5, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (4, 9) is:  17\n",
      "g cost of neighborNode:  (5, 9) plus its parentNode's:  (4, 9) g cost is:  23\n",
      "(5, 9)  added to open list\n",
      "h of neighborNode:  (5, 9) is:  12\n",
      "f cost of neighborNode:  (5, 9) is:  35\n",
      "\n",
      "Main for-loop iteration:  163\n",
      "The currentNode is:  (4, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 9) in iteration:  163\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 9) is on the array\n",
      "neighborNode (3, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 9)\n",
      "index after cast:  [3, 9]\n",
      "Obtain cost of node: [ 3 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (3, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (4, 9) is:  17\n",
      "g cost of neighborNode:  (3, 9) plus its parentNode's:  (4, 9) g cost is:  23\n",
      "(3, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  164\n",
      "The currentNode is:  (4, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 8) in iteration:  164\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 8) is on the array\n",
      "neighborNode (4, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 8)\n",
      "index after cast:  [4, 8]\n",
      "Obtain cost of node: [ 4 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 8) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 9) is:  17\n",
      "g cost of neighborNode:  (4, 8) plus its parentNode's:  (4, 9) g cost is:  22\n",
      "Current Node:  (5, 1)\n",
      "Unsuccessful goal check number:  42\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  165\n",
      "The currentNode is:  (5, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 2) in iteration:  165\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 2) is on the array\n",
      "neighborNode (5, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 2)\n",
      "index after cast:  [5, 2]\n",
      "Obtain cost of node: [ 5 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (5, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (5, 1) is:  26\n",
      "g cost of neighborNode:  (5, 2) plus its parentNode's:  (5, 1) g cost is:  26\n",
      "(5, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  166\n",
      "The currentNode is:  (5, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 1) in iteration:  166\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 1) is on the array\n",
      "neighborNode (6, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 1)\n",
      "index after cast:  [6, 1]\n",
      "Obtain cost of node: [ 6 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (6, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (5, 1) is:  26\n",
      "g cost of neighborNode:  (6, 1) plus its parentNode's:  (5, 1) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  167\n",
      "The currentNode is:  (5, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 1) in iteration:  167\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 1) is on the array\n",
      "neighborNode (4, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 1)\n",
      "index after cast:  [4, 1]\n",
      "Obtain cost of node: [ 4 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 1) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 1) is:  26\n",
      "g cost of neighborNode:  (4, 1) plus its parentNode's:  (5, 1) g cost is:  31\n",
      "(4, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  168\n",
      "The currentNode is:  (5, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 0) in iteration:  168\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 0) is on the array\n",
      "neighborNode (5, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 0)\n",
      "index after cast:  [5, 0]\n",
      "Obtain cost of node: [ 5 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 0) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 1) is:  26\n",
      "g cost of neighborNode:  (5, 0) plus its parentNode's:  (5, 1) g cost is:  33\n",
      "(5, 0)  added to open list\n",
      "h of neighborNode:  (5, 0) is:  5\n",
      "f cost of neighborNode:  (5, 0) is:  38\n",
      "Current Node:  (5, 5)\n",
      "Unsuccessful goal check number:  43\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  169\n",
      "The currentNode is:  (5, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 6) in iteration:  169\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 6) is on the array\n",
      "neighborNode (5, 6) has taken the value of checkNode\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function call to cost evaluation:\n",
      "index:  (5, 6)\n",
      "index after cast:  [5, 6]\n",
      "Obtain cost of node: [ 5 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (5, 6) without adding parent cost is:  8\n",
      "g cost of parent node:  (5, 5) is:  22\n",
      "g cost of neighborNode:  (5, 6) plus its parentNode's:  (5, 5) g cost is:  30\n",
      "\n",
      "Main for-loop iteration:  170\n",
      "The currentNode is:  (5, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 5) in iteration:  170\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 5) is on the array\n",
      "neighborNode (6, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 5)\n",
      "index after cast:  [6, 5]\n",
      "Obtain cost of node: [ 6 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 5) without adding parent cost is:  0\n",
      "g cost of parent node:  (5, 5) is:  22\n",
      "g cost of neighborNode:  (6, 5) plus its parentNode's:  (5, 5) g cost is:  22\n",
      "(6, 5)  added to open list\n",
      "h of neighborNode:  (6, 5) is:  7\n",
      "f cost of neighborNode:  (6, 5) is:  29\n",
      "\n",
      "Main for-loop iteration:  171\n",
      "The currentNode is:  (5, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 5) in iteration:  171\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 5) is on the array\n",
      "neighborNode (4, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 5)\n",
      "index after cast:  [4, 5]\n",
      "Obtain cost of node: [ 4 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (5, 5) is:  22\n",
      "g cost of neighborNode:  (4, 5) plus its parentNode's:  (5, 5) g cost is:  23\n",
      "(4, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  172\n",
      "The currentNode is:  (5, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 4) in iteration:  172\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 4) is on the array\n",
      "neighborNode (5, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 4)\n",
      "index after cast:  [5, 4]\n",
      "Obtain cost of node: [ 5 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 5) is:  22\n",
      "g cost of neighborNode:  (5, 4) plus its parentNode's:  (5, 5) g cost is:  27\n",
      "Current Node:  (6, 5)\n",
      "Unsuccessful goal check number:  44\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  173\n",
      "The currentNode is:  (6, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 6) in iteration:  173\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 6) is on the array\n",
      "neighborNode (6, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 6)\n",
      "index after cast:  [6, 6]\n",
      "Obtain cost of node: [ 6 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (6, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (6, 5) is:  22\n",
      "g cost of neighborNode:  (6, 6) plus its parentNode's:  (6, 5) g cost is:  25\n",
      "(6, 6)  added to open list\n",
      "h of neighborNode:  (6, 6) is:  8\n",
      "f cost of neighborNode:  (6, 6) is:  33\n",
      "\n",
      "Main for-loop iteration:  174\n",
      "The currentNode is:  (6, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 5) in iteration:  174\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 5) is on the array\n",
      "neighborNode (7, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 5)\n",
      "index after cast:  [7, 5]\n",
      "Obtain cost of node: [ 7 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (7, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (6, 5) is:  22\n",
      "g cost of neighborNode:  (7, 5) plus its parentNode's:  (6, 5) g cost is:  28\n",
      "(7, 5)  added to open list\n",
      "h of neighborNode:  (7, 5) is:  6\n",
      "f cost of neighborNode:  (7, 5) is:  34\n",
      "\n",
      "Main for-loop iteration:  175\n",
      "The currentNode is:  (6, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 5) in iteration:  175\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 5) is on the array\n",
      "neighborNode (5, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 5)\n",
      "index after cast:  [5, 5]\n",
      "Obtain cost of node: [ 5 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (5, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (6, 5) is:  22\n",
      "g cost of neighborNode:  (5, 5) plus its parentNode's:  (6, 5) g cost is:  23\n",
      "(5, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  176\n",
      "The currentNode is:  (6, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 4) in iteration:  176\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 4) is on the array\n",
      "neighborNode (6, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 4)\n",
      "index after cast:  [6, 4]\n",
      "Obtain cost of node: [ 6 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 5) is:  22\n",
      "g cost of neighborNode:  (6, 4) plus its parentNode's:  (6, 5) g cost is:  29\n",
      "(6, 4)  added to open list\n",
      "h of neighborNode:  (6, 4) is:  6\n",
      "f cost of neighborNode:  (6, 4) is:  35\n",
      "Current Node:  (4, 3)\n",
      "Unsuccessful goal check number:  45\n",
      "Closed Nodes:  {(1, 3), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  177\n",
      "The currentNode is:  (4, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 4) in iteration:  177\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 4) is on the array\n",
      "neighborNode (4, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 4)\n",
      "index after cast:  [4, 4]\n",
      "Obtain cost of node: [ 4 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 3) is:  24\n",
      "g cost of neighborNode:  (4, 4) plus its parentNode's:  (4, 3) g cost is:  29\n",
      "(4, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  178\n",
      "The currentNode is:  (4, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 3) in iteration:  178\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 3) is on the array\n",
      "neighborNode (5, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 3)\n",
      "index after cast:  [5, 3]\n",
      "Obtain cost of node: [ 5 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 3) is:  24\n",
      "g cost of neighborNode:  (5, 3) plus its parentNode's:  (4, 3) g cost is:  31\n",
      "\n",
      "Main for-loop iteration:  179\n",
      "The currentNode is:  (4, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 3) in iteration:  179\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 3) is on the array\n",
      "neighborNode (3, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 3)\n",
      "index after cast:  [3, 3]\n",
      "Obtain cost of node: [ 3 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 3) without adding parent cost is:  2\n",
      "g cost of parent node:  (4, 3) is:  24\n",
      "g cost of neighborNode:  (3, 3) plus its parentNode's:  (4, 3) g cost is:  26\n",
      "(3, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  180\n",
      "The currentNode is:  (4, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 2) in iteration:  180\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 2) is on the array\n",
      "neighborNode (4, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 2)\n",
      "index after cast:  [4, 2]\n",
      "Obtain cost of node: [ 4 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (4, 2) without adding parent cost is:  2\n",
      "g cost of parent node:  (4, 3) is:  24\n",
      "g cost of neighborNode:  (4, 2) plus its parentNode's:  (4, 3) g cost is:  26\n",
      "(4, 2) not pushed\n",
      "Current Node:  (4, 8)\n",
      "Unsuccessful goal check number:  46\n",
      "Closed Nodes:  {(1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  181\n",
      "The currentNode is:  (4, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 9) in iteration:  181\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 9) is on the array\n",
      "neighborNode (4, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 9)\n",
      "index after cast:  [4, 9]\n",
      "Obtain cost of node: [ 4 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (4, 9) without adding parent cost is:  4\n",
      "g cost of parent node:  (4, 8) is:  19\n",
      "g cost of neighborNode:  (4, 9) plus its parentNode's:  (4, 8) g cost is:  23\n",
      "(4, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  182\n",
      "The currentNode is:  (4, 8)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 8) in iteration:  182\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 8) is on the array\n",
      "neighborNode (5, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 8)\n",
      "index after cast:  [5, 8]\n",
      "Obtain cost of node: [ 5 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (5, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (4, 8) is:  19\n",
      "g cost of neighborNode:  (5, 8) plus its parentNode's:  (4, 8) g cost is:  28\n",
      "(5, 8)  added to open list\n",
      "h of neighborNode:  (5, 8) is:  11\n",
      "f cost of neighborNode:  (5, 8) is:  39\n",
      "\n",
      "Main for-loop iteration:  183\n",
      "The currentNode is:  (4, 8)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 8) in iteration:  183\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 8) is on the array\n",
      "neighborNode (3, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 8)\n",
      "index after cast:  [3, 8]\n",
      "Obtain cost of node: [ 3 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 8) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 8) is:  19\n",
      "g cost of neighborNode:  (3, 8) plus its parentNode's:  (4, 8) g cost is:  20\n",
      "(3, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  184\n",
      "The currentNode is:  (4, 8)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 7) in iteration:  184\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 7) is on the array\n",
      "neighborNode (4, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 7)\n",
      "index after cast:  [4, 7]\n",
      "Obtain cost of node: [ 4 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 7) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 8) is:  19\n",
      "g cost of neighborNode:  (4, 7) plus its parentNode's:  (4, 8) g cost is:  26\n",
      "Current Node:  (6, 1)\n",
      "Unsuccessful goal check number:  47\n",
      "Closed Nodes:  {(1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  185\n",
      "The currentNode is:  (6, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 2) in iteration:  185\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 2) is on the array\n",
      "neighborNode (6, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 2)\n",
      "index after cast:  [6, 2]\n",
      "Obtain cost of node: [ 6 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 1) is:  28\n",
      "g cost of neighborNode:  (6, 2) plus its parentNode's:  (6, 1) g cost is:  28\n",
      "(6, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  186\n",
      "The currentNode is:  (6, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 1) in iteration:  186\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 1) is on the array\n",
      "neighborNode (7, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 1)\n",
      "index after cast:  [7, 1]\n",
      "Obtain cost of node: [ 7 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (7, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (6, 1) is:  28\n",
      "g cost of neighborNode:  (7, 1) plus its parentNode's:  (6, 1) g cost is:  36\n",
      "(7, 1)  added to open list\n",
      "h of neighborNode:  (7, 1) is:  2\n",
      "f cost of neighborNode:  (7, 1) is:  38\n",
      "\n",
      "Main for-loop iteration:  187\n",
      "The currentNode is:  (6, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 1) in iteration:  187\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 1) is on the array\n",
      "neighborNode (5, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 1)\n",
      "index after cast:  [5, 1]\n",
      "Obtain cost of node: [ 5 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (5, 1) without adding parent cost is:  6\n",
      "g cost of parent node:  (6, 1) is:  28\n",
      "g cost of neighborNode:  (5, 1) plus its parentNode's:  (6, 1) g cost is:  34\n",
      "(5, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  188\n",
      "The currentNode is:  (6, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 0) in iteration:  188\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 0) is on the array\n",
      "neighborNode (6, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 0)\n",
      "index after cast:  [6, 0]\n",
      "Obtain cost of node: [ 6 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (6, 0) without adding parent cost is:  3\n",
      "g cost of parent node:  (6, 1) is:  28\n",
      "g cost of neighborNode:  (6, 0) plus its parentNode's:  (6, 1) g cost is:  31\n",
      "(6, 0)  added to open list\n",
      "h of neighborNode:  (6, 0) is:  4\n",
      "f cost of neighborNode:  (6, 0) is:  35\n",
      "Current Node:  (0, 4)\n",
      "Unsuccessful goal check number:  48\n",
      "Closed Nodes:  {(1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  189\n",
      "The currentNode is:  (0, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (0, 5) in iteration:  189\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 5) is on the array\n",
      "neighborNode (0, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 5)\n",
      "index after cast:  [0, 5]\n",
      "Obtain cost of node: [ 0 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (0, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (0, 4) is:  20\n",
      "g cost of neighborNode:  (0, 5) plus its parentNode's:  (0, 4) g cost is:  21\n",
      "(0, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  190\n",
      "The currentNode is:  (0, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 4) in iteration:  190\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 4) is on the array\n",
      "neighborNode (1, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 4)\n",
      "index after cast:  [1, 4]\n",
      "Obtain cost of node: [ 1 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (1, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (0, 4) is:  20\n",
      "g cost of neighborNode:  (1, 4) plus its parentNode's:  (0, 4) g cost is:  22\n",
      "(1, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  191\n",
      "The currentNode is:  (0, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (-1, 4) in iteration:  191\n",
      "(-1, 4) :not on array\n",
      "\n",
      "Main for-loop iteration:  192\n",
      "The currentNode is:  (0, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (0, 3) in iteration:  192\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 3) is on the array\n",
      "neighborNode (0, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 3)\n",
      "index after cast:  [0, 3]\n",
      "Obtain cost of node: [ 0 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (0, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (0, 4) is:  20\n",
      "g cost of neighborNode:  (0, 3) plus its parentNode's:  (0, 4) g cost is:  20\n",
      "(0, 3) not pushed\n",
      "Current Node:  (1, 0)\n",
      "Unsuccessful goal check number:  49\n",
      "Closed Nodes:  {(1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  193\n",
      "The currentNode is:  (1, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (1, 1) in iteration:  193\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 1) is on the array\n",
      "neighborNode (1, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 1)\n",
      "index after cast:  [1, 1]\n",
      "Obtain cost of node: [ 1 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (1, 1) without adding parent cost is:  4\n",
      "g cost of parent node:  (1, 0) is:  23\n",
      "g cost of neighborNode:  (1, 1) plus its parentNode's:  (1, 0) g cost is:  27\n",
      "(1, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  194\n",
      "The currentNode is:  (1, 0)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 0) in iteration:  194\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 0) is on the array\n",
      "neighborNode (2, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 0)\n",
      "index after cast:  [2, 0]\n",
      "Obtain cost of node: [ 2 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (2, 0) without adding parent cost is:  6\n",
      "g cost of parent node:  (1, 0) is:  23\n",
      "g cost of neighborNode:  (2, 0) plus its parentNode's:  (1, 0) g cost is:  29\n",
      "(2, 0)  added to open list\n",
      "h of neighborNode:  (2, 0) is:  8\n",
      "f cost of neighborNode:  (2, 0) is:  37\n",
      "\n",
      "Main for-loop iteration:  195\n",
      "The currentNode is:  (1, 0)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (0, 0) in iteration:  195\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (0, 0) is on the array\n",
      "neighborNode (0, 0) has taken the value of checkNode\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 0)\n",
      "index after cast:  [0, 0]\n",
      "Obtain cost of node: [ 0 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (0, 0) without adding parent cost is:  9\n",
      "g cost of parent node:  (1, 0) is:  23\n",
      "g cost of neighborNode:  (0, 0) plus its parentNode's:  (1, 0) g cost is:  32\n",
      "\n",
      "Main for-loop iteration:  196\n",
      "The currentNode is:  (1, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (1, -1) in iteration:  196\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "(1, -1) :not on array\n",
      "Current Node:  (4, 7)\n",
      "Unsuccessful goal check number:  50\n",
      "Closed Nodes:  {(4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  197\n",
      "The currentNode is:  (4, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 8) in iteration:  197\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 8) is on the array\n",
      "neighborNode (4, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 8)\n",
      "index after cast:  [4, 8]\n",
      "Obtain cost of node: [ 4 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 8) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 7) is:  21\n",
      "g cost of neighborNode:  (4, 8) plus its parentNode's:  (4, 7) g cost is:  26\n",
      "(4, 8) not pushed\n",
      "\n",
      "Main for-loop iteration:  198\n",
      "The currentNode is:  (4, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 7) in iteration:  198\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 7) is on the array\n",
      "neighborNode (5, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 7)\n",
      "index after cast:  [5, 7]\n",
      "Obtain cost of node: [ 5 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 7) is:  21\n",
      "g cost of neighborNode:  (5, 7) plus its parentNode's:  (4, 7) g cost is:  26\n",
      "(5, 7)  added to open list\n",
      "h of neighborNode:  (5, 7) is:  10\n",
      "f cost of neighborNode:  (5, 7) is:  36\n",
      "\n",
      "Main for-loop iteration:  199\n",
      "The currentNode is:  (4, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 7) in iteration:  199\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 7) is on the array\n",
      "neighborNode (3, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 7)\n",
      "index after cast:  [3, 7]\n",
      "Obtain cost of node: [ 3 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (3, 7) without adding parent cost is:  4\n",
      "g cost of parent node:  (4, 7) is:  21\n",
      "g cost of neighborNode:  (3, 7) plus its parentNode's:  (4, 7) g cost is:  25\n",
      "(3, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  200\n",
      "The currentNode is:  (4, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, 6) in iteration:  200\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 6) is on the array\n",
      "neighborNode (4, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 6)\n",
      "index after cast:  [4, 6]\n",
      "Obtain cost of node: [ 4 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 6) without adding parent cost is:  1\n",
      "g cost of parent node:  (4, 7) is:  21\n",
      "g cost of neighborNode:  (4, 6) plus its parentNode's:  (4, 7) g cost is:  22\n",
      "(4, 6) not pushed\n",
      "Current Node:  (5, 4)\n",
      "Unsuccessful goal check number:  51\n",
      "Closed Nodes:  {(4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  201\n",
      "The currentNode is:  (5, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 5) in iteration:  201\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 5) is on the array\n",
      "neighborNode (5, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 5)\n",
      "index after cast:  [5, 5]\n",
      "Obtain cost of node: [ 5 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (5, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (5, 4) is:  25\n",
      "g cost of neighborNode:  (5, 5) plus its parentNode's:  (5, 4) g cost is:  26\n",
      "(5, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  202\n",
      "The currentNode is:  (5, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 4) in iteration:  202\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 4) is on the array\n",
      "neighborNode (6, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 4)\n",
      "index after cast:  [6, 4]\n",
      "Obtain cost of node: [ 6 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 4) is:  25\n",
      "g cost of neighborNode:  (6, 4) plus its parentNode's:  (5, 4) g cost is:  32\n",
      "\n",
      "Main for-loop iteration:  203\n",
      "The currentNode is:  (5, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 4) in iteration:  203\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 4) is on the array\n",
      "neighborNode (4, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 4)\n",
      "index after cast:  [4, 4]\n",
      "Obtain cost of node: [ 4 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 4) is:  25\n",
      "g cost of neighborNode:  (4, 4) plus its parentNode's:  (5, 4) g cost is:  30\n",
      "(4, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  204\n",
      "The currentNode is:  (5, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 3) in iteration:  204\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 3) is on the array\n",
      "neighborNode (5, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 3)\n",
      "index after cast:  [5, 3]\n",
      "Obtain cost of node: [ 5 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 4) is:  25\n",
      "g cost of neighborNode:  (5, 3) plus its parentNode's:  (5, 4) g cost is:  32\n",
      "Current Node:  (6, 3)\n",
      "Unsuccessful goal check number:  52\n",
      "Closed Nodes:  {(4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  205\n",
      "The currentNode is:  (6, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 4) in iteration:  205\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 4) is on the array\n",
      "neighborNode (6, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 4)\n",
      "index after cast:  [6, 4]\n",
      "Obtain cost of node: [ 6 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 3) is:  27\n",
      "g cost of neighborNode:  (6, 4) plus its parentNode's:  (6, 3) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  206\n",
      "The currentNode is:  (6, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 3) in iteration:  206\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 3) is on the array\n",
      "neighborNode (7, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 3)\n",
      "index after cast:  [7, 3]\n",
      "Obtain cost of node: [ 7 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 3) is:  27\n",
      "g cost of neighborNode:  (7, 3) plus its parentNode's:  (6, 3) g cost is:  27\n",
      "(7, 3)  added to open list\n",
      "h of neighborNode:  (7, 3) is:  4\n",
      "f cost of neighborNode:  (7, 3) is:  31\n",
      "\n",
      "Main for-loop iteration:  207\n",
      "The currentNode is:  (6, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 3) in iteration:  207\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 3) is on the array\n",
      "neighborNode (5, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 3)\n",
      "index after cast:  [5, 3]\n",
      "Obtain cost of node: [ 5 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 3) is:  27\n",
      "g cost of neighborNode:  (5, 3) plus its parentNode's:  (6, 3) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  208\n",
      "The currentNode is:  (6, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 2) in iteration:  208\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 2) is on the array\n",
      "neighborNode (6, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 2)\n",
      "index after cast:  [6, 2]\n",
      "Obtain cost of node: [ 6 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 3) is:  27\n",
      "g cost of neighborNode:  (6, 2) plus its parentNode's:  (6, 3) g cost is:  27\n",
      "(6, 2) not pushed\n",
      "Current Node:  (7, 3)\n",
      "Unsuccessful goal check number:  53\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  209\n",
      "The currentNode is:  (7, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (7, 4) in iteration:  209\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 4) is on the array\n",
      "neighborNode (7, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 4)\n",
      "index after cast:  [7, 4]\n",
      "Obtain cost of node: [ 7 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (7, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (7, 3) is:  27\n",
      "g cost of neighborNode:  (7, 4) plus its parentNode's:  (7, 3) g cost is:  34\n",
      "(7, 4)  added to open list\n",
      "h of neighborNode:  (7, 4) is:  5\n",
      "f cost of neighborNode:  (7, 4) is:  39\n",
      "\n",
      "Main for-loop iteration:  210\n",
      "The currentNode is:  (7, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 3) in iteration:  210\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 3) is on the array\n",
      "neighborNode (8, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 3)\n",
      "index after cast:  [8, 3]\n",
      "Obtain cost of node: [ 8 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (8, 3) without adding parent cost is:  4\n",
      "g cost of parent node:  (7, 3) is:  27\n",
      "g cost of neighborNode:  (8, 3) plus its parentNode's:  (7, 3) g cost is:  31\n",
      "(8, 3)  added to open list\n",
      "h of neighborNode:  (8, 3) is:  3\n",
      "f cost of neighborNode:  (8, 3) is:  34\n",
      "\n",
      "Main for-loop iteration:  211\n",
      "The currentNode is:  (7, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 3) in iteration:  211\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 3) is on the array\n",
      "neighborNode (6, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 3)\n",
      "index after cast:  [6, 3]\n",
      "Obtain cost of node: [ 6 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (7, 3) is:  27\n",
      "g cost of neighborNode:  (6, 3) plus its parentNode's:  (7, 3) g cost is:  34\n",
      "(6, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  212\n",
      "The currentNode is:  (7, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (7, 2) in iteration:  212\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 2) is on the array\n",
      "neighborNode (7, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 2)\n",
      "index after cast:  [7, 2]\n",
      "Obtain cost of node: [ 7 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (7, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (7, 3) is:  27\n",
      "g cost of neighborNode:  (7, 2) plus its parentNode's:  (7, 3) g cost is:  36\n",
      "Current Node:  (7, 2)\n",
      "Unsuccessful goal check number:  54\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  213\n",
      "The currentNode is:  (7, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (7, 3) in iteration:  213\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 3) is on the array\n",
      "neighborNode (7, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 3)\n",
      "index after cast:  [7, 3]\n",
      "Obtain cost of node: [ 7 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 2) is:  29\n",
      "g cost of neighborNode:  (7, 3) plus its parentNode's:  (7, 2) g cost is:  29\n",
      "(7, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  214\n",
      "The currentNode is:  (7, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 2) in iteration:  214\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 2) is on the array\n",
      "neighborNode (8, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 2)\n",
      "index after cast:  [8, 2]\n",
      "Obtain cost of node: [ 8 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (8, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 2) is:  29\n",
      "g cost of neighborNode:  (8, 2) plus its parentNode's:  (7, 2) g cost is:  29\n",
      "(8, 2)  added to open list\n",
      "h of neighborNode:  (8, 2) is:  2\n",
      "f cost of neighborNode:  (8, 2) is:  31\n",
      "\n",
      "Main for-loop iteration:  215\n",
      "The currentNode is:  (7, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 2) in iteration:  215\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 2) is on the array\n",
      "neighborNode (6, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 2)\n",
      "index after cast:  [6, 2]\n",
      "Obtain cost of node: [ 6 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 2) is:  29\n",
      "g cost of neighborNode:  (6, 2) plus its parentNode's:  (7, 2) g cost is:  29\n",
      "(6, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  216\n",
      "The currentNode is:  (7, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (7, 1) in iteration:  216\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 1) is on the array\n",
      "neighborNode (7, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 1)\n",
      "index after cast:  [7, 1]\n",
      "Obtain cost of node: [ 7 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (7, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (7, 2) is:  29\n",
      "g cost of neighborNode:  (7, 1) plus its parentNode's:  (7, 2) g cost is:  37\n",
      "Current Node:  (8, 2)\n",
      "Unsuccessful goal check number:  55\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  217\n",
      "The currentNode is:  (8, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 3) in iteration:  217\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 3) is on the array\n",
      "neighborNode (8, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 3)\n",
      "index after cast:  [8, 3]\n",
      "Obtain cost of node: [ 8 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (8, 3) without adding parent cost is:  4\n",
      "g cost of parent node:  (8, 2) is:  29\n",
      "g cost of neighborNode:  (8, 3) plus its parentNode's:  (8, 2) g cost is:  33\n",
      "\n",
      "Main for-loop iteration:  218\n",
      "The currentNode is:  (8, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 2) in iteration:  218\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 2) is on the array\n",
      "neighborNode (9, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 2)\n",
      "index after cast:  [9, 2]\n",
      "Obtain cost of node: [ 9 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (9, 2) without adding parent cost is:  8\n",
      "g cost of parent node:  (8, 2) is:  29\n",
      "g cost of neighborNode:  (9, 2) plus its parentNode's:  (8, 2) g cost is:  37\n",
      "(9, 2)  added to open list\n",
      "h of neighborNode:  (9, 2) is:  1\n",
      "f cost of neighborNode:  (9, 2) is:  38\n",
      "\n",
      "Main for-loop iteration:  219\n",
      "The currentNode is:  (8, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 2) in iteration:  219\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 2) is on the array\n",
      "neighborNode (7, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 2)\n",
      "index after cast:  [7, 2]\n",
      "Obtain cost of node: [ 7 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (7, 2) without adding parent cost is:  9\n",
      "g cost of parent node:  (8, 2) is:  29\n",
      "g cost of neighborNode:  (7, 2) plus its parentNode's:  (8, 2) g cost is:  38\n",
      "(7, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  220\n",
      "The currentNode is:  (8, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 1) in iteration:  220\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 1) is on the array\n",
      "neighborNode (8, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 1)\n",
      "index after cast:  [8, 1]\n",
      "Obtain cost of node: [ 8 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (8, 1) without adding parent cost is:  4\n",
      "g cost of parent node:  (8, 2) is:  29\n",
      "g cost of neighborNode:  (8, 1) plus its parentNode's:  (8, 2) g cost is:  33\n",
      "(8, 1)  added to open list\n",
      "h of neighborNode:  (8, 1) is:  1\n",
      "f cost of neighborNode:  (8, 1) is:  34\n",
      "Current Node:  (3, 1)\n",
      "Unsuccessful goal check number:  56\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  221\n",
      "The currentNode is:  (3, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 2) in iteration:  221\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 2) is on the array\n",
      "neighborNode (3, 2) has taken the value of checkNode\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 2)\n",
      "index after cast:  [3, 2]\n",
      "Obtain cost of node: [ 3 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 2) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 1) is:  27\n",
      "g cost of neighborNode:  (3, 2) plus its parentNode's:  (3, 1) g cost is:  28\n",
      "(3, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  222\n",
      "The currentNode is:  (3, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 1) in iteration:  222\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 1) is on the array\n",
      "neighborNode (4, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 1)\n",
      "index after cast:  [4, 1]\n",
      "Obtain cost of node: [ 4 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 1) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 1) is:  27\n",
      "g cost of neighborNode:  (4, 1) plus its parentNode's:  (3, 1) g cost is:  32\n",
      "(4, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  223\n",
      "The currentNode is:  (3, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 1) in iteration:  223\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 1) is on the array\n",
      "neighborNode (2, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 1)\n",
      "index after cast:  [2, 1]\n",
      "Obtain cost of node: [ 2 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (3, 1) is:  27\n",
      "g cost of neighborNode:  (2, 1) plus its parentNode's:  (3, 1) g cost is:  36\n",
      "\n",
      "Main for-loop iteration:  224\n",
      "The currentNode is:  (3, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 0) in iteration:  224\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 0) is on the array\n",
      "neighborNode (3, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 0)\n",
      "index after cast:  [3, 0]\n",
      "Obtain cost of node: [ 3 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (3, 0) without adding parent cost is:  8\n",
      "g cost of parent node:  (3, 1) is:  27\n",
      "g cost of neighborNode:  (3, 0) plus its parentNode's:  (3, 1) g cost is:  35\n",
      "(3, 0)  added to open list\n",
      "h of neighborNode:  (3, 0) is:  7\n",
      "f cost of neighborNode:  (3, 0) is:  42\n",
      "Current Node:  (3, 5)\n",
      "Unsuccessful goal check number:  57\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  225\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 6) in iteration:  225\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 6) is on the array\n",
      "neighborNode (3, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 6)\n",
      "index after cast:  [3, 6]\n",
      "Obtain cost of node: [ 3 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (3, 6) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (3, 6) plus its parentNode's:  (3, 5) g cost is:  28\n",
      "(3, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  226\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 5) in iteration:  226\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 5) is on the array\n",
      "neighborNode (4, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 5)\n",
      "index after cast:  [4, 5]\n",
      "Obtain cost of node: [ 4 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (4, 5) plus its parentNode's:  (3, 5) g cost is:  24\n",
      "(4, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  227\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 5) in iteration:  227\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 5) is on the array\n",
      "neighborNode (2, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 5)\n",
      "index after cast:  [2, 5]\n",
      "Obtain cost of node: [ 2 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (2, 5) without adding parent cost is:  3\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (2, 5) plus its parentNode's:  (3, 5) g cost is:  26\n",
      "(2, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  228\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 4) in iteration:  228\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 4) is on the array\n",
      "neighborNode (3, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (3, 4) plus its parentNode's:  (3, 5) g cost is:  25\n",
      "(3, 4) not pushed\n",
      "Current Node:  (4, 0)\n",
      "Unsuccessful goal check number:  58\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  229\n",
      "The currentNode is:  (4, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (4, 1) in iteration:  229\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 1) is on the array\n",
      "neighborNode (4, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 1)\n",
      "index after cast:  [4, 1]\n",
      "Obtain cost of node: [ 4 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (4, 1) without adding parent cost is:  5\n",
      "g cost of parent node:  (4, 0) is:  27\n",
      "g cost of neighborNode:  (4, 1) plus its parentNode's:  (4, 0) g cost is:  32\n",
      "(4, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  230\n",
      "The currentNode is:  (4, 0)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 0) in iteration:  230\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 0) is on the array\n",
      "neighborNode (5, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 0)\n",
      "index after cast:  [5, 0]\n",
      "Obtain cost of node: [ 5 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 0) without adding parent cost is:  7\n",
      "g cost of parent node:  (4, 0) is:  27\n",
      "g cost of neighborNode:  (5, 0) plus its parentNode's:  (4, 0) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  231\n",
      "The currentNode is:  (4, 0)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 0) in iteration:  231\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 0) is on the array\n",
      "neighborNode (3, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 0)\n",
      "index after cast:  [3, 0]\n",
      "Obtain cost of node: [ 3 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (3, 0) without adding parent cost is:  8\n",
      "g cost of parent node:  (4, 0) is:  27\n",
      "g cost of neighborNode:  (3, 0) plus its parentNode's:  (4, 0) g cost is:  35\n",
      "\n",
      "Main for-loop iteration:  232\n",
      "The currentNode is:  (4, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (4, -1) in iteration:  232\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "(4, -1) :not on array\n",
      "Current Node:  (5, 3)\n",
      "Unsuccessful goal check number:  59\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  233\n",
      "The currentNode is:  (5, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 4) in iteration:  233\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 4) is on the array\n",
      "neighborNode (5, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 4)\n",
      "index after cast:  [5, 4]\n",
      "Obtain cost of node: [ 5 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 3) is:  27\n",
      "g cost of neighborNode:  (5, 4) plus its parentNode's:  (5, 3) g cost is:  32\n",
      "(5, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  234\n",
      "The currentNode is:  (5, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 3) in iteration:  234\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 3) is on the array\n",
      "neighborNode (6, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 3)\n",
      "index after cast:  [6, 3]\n",
      "Obtain cost of node: [ 6 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 3) is:  27\n",
      "g cost of neighborNode:  (6, 3) plus its parentNode's:  (5, 3) g cost is:  34\n",
      "(6, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  235\n",
      "The currentNode is:  (5, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 3) in iteration:  235\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 3) is on the array\n",
      "neighborNode (4, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 3)\n",
      "index after cast:  [4, 3]\n",
      "Obtain cost of node: [ 4 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 3) is:  27\n",
      "g cost of neighborNode:  (4, 3) plus its parentNode's:  (5, 3) g cost is:  34\n",
      "(4, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  236\n",
      "The currentNode is:  (5, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 2) in iteration:  236\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 2) is on the array\n",
      "neighborNode (5, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 2)\n",
      "index after cast:  [5, 2]\n",
      "Obtain cost of node: [ 5 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (5, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (5, 3) is:  27\n",
      "g cost of neighborNode:  (5, 2) plus its parentNode's:  (5, 3) g cost is:  27\n",
      "(5, 2) not pushed\n",
      "Current Node:  (6, 6)\n",
      "Unsuccessful goal check number:  60\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  237\n",
      "The currentNode is:  (6, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 7) in iteration:  237\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 7) is on the array\n",
      "neighborNode (6, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 7)\n",
      "index after cast:  [6, 7]\n",
      "Obtain cost of node: [ 6 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (6, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (6, 6) is:  25\n",
      "g cost of neighborNode:  (6, 7) plus its parentNode's:  (6, 6) g cost is:  30\n",
      "(6, 7)  added to open list\n",
      "h of neighborNode:  (6, 7) is:  9\n",
      "f cost of neighborNode:  (6, 7) is:  39\n",
      "\n",
      "Main for-loop iteration:  238\n",
      "The currentNode is:  (6, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 6) in iteration:  238\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 6) is on the array\n",
      "neighborNode (7, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 6)\n",
      "index after cast:  [7, 6]\n",
      "Obtain cost of node: [ 7 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 6) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 6) is:  25\n",
      "g cost of neighborNode:  (7, 6) plus its parentNode's:  (6, 6) g cost is:  25\n",
      "(7, 6)  added to open list\n",
      "h of neighborNode:  (7, 6) is:  7\n",
      "f cost of neighborNode:  (7, 6) is:  32\n",
      "\n",
      "Main for-loop iteration:  239\n",
      "The currentNode is:  (6, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 6) in iteration:  239\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 6) is on the array\n",
      "neighborNode (5, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 6)\n",
      "index after cast:  [5, 6]\n",
      "Obtain cost of node: [ 5 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (5, 6) without adding parent cost is:  8\n",
      "g cost of parent node:  (6, 6) is:  25\n",
      "g cost of neighborNode:  (5, 6) plus its parentNode's:  (6, 6) g cost is:  33\n",
      "\n",
      "Main for-loop iteration:  240\n",
      "The currentNode is:  (6, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 5) in iteration:  240\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 5) is on the array\n",
      "neighborNode (6, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 5)\n",
      "index after cast:  [6, 5]\n",
      "Obtain cost of node: [ 6 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 5) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 6) is:  25\n",
      "g cost of neighborNode:  (6, 5) plus its parentNode's:  (6, 6) g cost is:  25\n",
      "(6, 5) not pushed\n",
      "Current Node:  (7, 6)\n",
      "Unsuccessful goal check number:  61\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  241\n",
      "The currentNode is:  (7, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (7, 7) in iteration:  241\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 7) is on the array\n",
      "neighborNode (7, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 7)\n",
      "index after cast:  [7, 7]\n",
      "Obtain cost of node: [ 7 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (7, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (7, 6) is:  25\n",
      "g cost of neighborNode:  (7, 7) plus its parentNode's:  (7, 6) g cost is:  26\n",
      "(7, 7)  added to open list\n",
      "h of neighborNode:  (7, 7) is:  8\n",
      "f cost of neighborNode:  (7, 7) is:  34\n",
      "\n",
      "Main for-loop iteration:  242\n",
      "The currentNode is:  (7, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 6) in iteration:  242\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 6) is on the array\n",
      "neighborNode (8, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 6)\n",
      "index after cast:  [8, 6]\n",
      "Obtain cost of node: [ 8 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (8, 6) without adding parent cost is:  2\n",
      "g cost of parent node:  (7, 6) is:  25\n",
      "g cost of neighborNode:  (8, 6) plus its parentNode's:  (7, 6) g cost is:  27\n",
      "(8, 6)  added to open list\n",
      "h of neighborNode:  (8, 6) is:  6\n",
      "f cost of neighborNode:  (8, 6) is:  33\n",
      "\n",
      "Main for-loop iteration:  243\n",
      "The currentNode is:  (7, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 6) in iteration:  243\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 6) is on the array\n",
      "neighborNode (6, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 6)\n",
      "index after cast:  [6, 6]\n",
      "Obtain cost of node: [ 6 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (6, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (7, 6) is:  25\n",
      "g cost of neighborNode:  (6, 6) plus its parentNode's:  (7, 6) g cost is:  28\n",
      "(6, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  244\n",
      "The currentNode is:  (7, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (7, 5) in iteration:  244\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 5) is on the array\n",
      "neighborNode (7, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 5)\n",
      "index after cast:  [7, 5]\n",
      "Obtain cost of node: [ 7 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (7, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (7, 6) is:  25\n",
      "g cost of neighborNode:  (7, 5) plus its parentNode's:  (7, 6) g cost is:  31\n",
      "Current Node:  (8, 6)\n",
      "Unsuccessful goal check number:  62\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  245\n",
      "The currentNode is:  (8, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 7) in iteration:  245\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 7) is on the array\n",
      "neighborNode (8, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 7)\n",
      "index after cast:  [8, 7]\n",
      "Obtain cost of node: [ 8 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (8, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (8, 6) is:  27\n",
      "g cost of neighborNode:  (8, 7) plus its parentNode's:  (8, 6) g cost is:  28\n",
      "(8, 7)  added to open list\n",
      "h of neighborNode:  (8, 7) is:  7\n",
      "f cost of neighborNode:  (8, 7) is:  35\n",
      "\n",
      "Main for-loop iteration:  246\n",
      "The currentNode is:  (8, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 6) in iteration:  246\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 6) is on the array\n",
      "neighborNode (9, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 6)\n",
      "index after cast:  [9, 6]\n",
      "Obtain cost of node: [ 9 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (9, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (8, 6) is:  27\n",
      "g cost of neighborNode:  (9, 6) plus its parentNode's:  (8, 6) g cost is:  30\n",
      "(9, 6)  added to open list\n",
      "h of neighborNode:  (9, 6) is:  5\n",
      "f cost of neighborNode:  (9, 6) is:  35\n",
      "\n",
      "Main for-loop iteration:  247\n",
      "The currentNode is:  (8, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 6) in iteration:  247\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 6) is on the array\n",
      "neighborNode (7, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 6)\n",
      "index after cast:  [7, 6]\n",
      "Obtain cost of node: [ 7 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 6) without adding parent cost is:  0\n",
      "g cost of parent node:  (8, 6) is:  27\n",
      "g cost of neighborNode:  (7, 6) plus its parentNode's:  (8, 6) g cost is:  27\n",
      "(7, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  248\n",
      "The currentNode is:  (8, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 5) in iteration:  248\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 5) is on the array\n",
      "neighborNode (8, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 5)\n",
      "index after cast:  [8, 5]\n",
      "Obtain cost of node: [ 8 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (8, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (8, 6) is:  27\n",
      "g cost of neighborNode:  (8, 5) plus its parentNode's:  (8, 6) g cost is:  33\n",
      "(8, 5)  added to open list\n",
      "h of neighborNode:  (8, 5) is:  5\n",
      "f cost of neighborNode:  (8, 5) is:  38\n",
      "Current Node:  (3, 5)\n",
      "Unsuccessful goal check number:  63\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  249\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (3, 6) in iteration:  249\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 6) is on the array\n",
      "neighborNode (3, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 6)\n",
      "index after cast:  [3, 6]\n",
      "Obtain cost of node: [ 3 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (3, 6) without adding parent cost is:  5\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (3, 6) plus its parentNode's:  (3, 5) g cost is:  28\n",
      "(3, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  250\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 5) in iteration:  250\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 5) is on the array\n",
      "neighborNode (4, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 5)\n",
      "index after cast:  [4, 5]\n",
      "Obtain cost of node: [ 4 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (4, 5) plus its parentNode's:  (3, 5) g cost is:  24\n",
      "(4, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  251\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (2, 5) in iteration:  251\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 5) is on the array\n",
      "neighborNode (2, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 5)\n",
      "index after cast:  [2, 5]\n",
      "Obtain cost of node: [ 2 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (2, 5) without adding parent cost is:  3\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (2, 5) plus its parentNode's:  (3, 5) g cost is:  26\n",
      "(2, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  252\n",
      "The currentNode is:  (3, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (3, 4) in iteration:  252\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 4) is on the array\n",
      "neighborNode (3, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (3, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (3, 5) is:  23\n",
      "g cost of neighborNode:  (3, 4) plus its parentNode's:  (3, 5) g cost is:  25\n",
      "(3, 4) not pushed\n",
      "Current Node:  (7, 5)\n",
      "Unsuccessful goal check number:  64\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  253\n",
      "The currentNode is:  (7, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (7, 6) in iteration:  253\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 6) is on the array\n",
      "neighborNode (7, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 6)\n",
      "index after cast:  [7, 6]\n",
      "Obtain cost of node: [ 7 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 6) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 5) is:  28\n",
      "g cost of neighborNode:  (7, 6) plus its parentNode's:  (7, 5) g cost is:  28\n",
      "(7, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  254\n",
      "The currentNode is:  (7, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 5) in iteration:  254\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 5) is on the array\n",
      "neighborNode (8, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 5)\n",
      "index after cast:  [8, 5]\n",
      "Obtain cost of node: [ 8 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (8, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (7, 5) is:  28\n",
      "g cost of neighborNode:  (8, 5) plus its parentNode's:  (7, 5) g cost is:  34\n",
      "\n",
      "Main for-loop iteration:  255\n",
      "The currentNode is:  (7, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 5) in iteration:  255\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 5) is on the array\n",
      "neighborNode (6, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 5)\n",
      "index after cast:  [6, 5]\n",
      "Obtain cost of node: [ 6 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 5) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 5) is:  28\n",
      "g cost of neighborNode:  (6, 5) plus its parentNode's:  (7, 5) g cost is:  28\n",
      "(6, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  256\n",
      "The currentNode is:  (7, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (7, 4) in iteration:  256\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 4) is on the array\n",
      "neighborNode (7, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 4)\n",
      "index after cast:  [7, 4]\n",
      "Obtain cost of node: [ 7 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (7, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (7, 5) is:  28\n",
      "g cost of neighborNode:  (7, 4) plus its parentNode's:  (7, 5) g cost is:  35\n",
      "Current Node:  (7, 7)\n",
      "Unsuccessful goal check number:  65\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  257\n",
      "The currentNode is:  (7, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (7, 8) in iteration:  257\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 8) is on the array\n",
      "neighborNode (7, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 8)\n",
      "index after cast:  [7, 8]\n",
      "Obtain cost of node: [ 7 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (7, 8) without adding parent cost is:  8\n",
      "g cost of parent node:  (7, 7) is:  26\n",
      "g cost of neighborNode:  (7, 8) plus its parentNode's:  (7, 7) g cost is:  34\n",
      "(7, 8)  added to open list\n",
      "h of neighborNode:  (7, 8) is:  9\n",
      "f cost of neighborNode:  (7, 8) is:  43\n",
      "\n",
      "Main for-loop iteration:  258\n",
      "The currentNode is:  (7, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 7) in iteration:  258\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 7) is on the array\n",
      "neighborNode (8, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 7)\n",
      "index after cast:  [8, 7]\n",
      "Obtain cost of node: [ 8 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (8, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (7, 7) is:  26\n",
      "g cost of neighborNode:  (8, 7) plus its parentNode's:  (7, 7) g cost is:  27\n",
      "(8, 7)  added to open list\n",
      "h of neighborNode:  (8, 7) is:  7\n",
      "f cost of neighborNode:  (8, 7) is:  34\n",
      "\n",
      "Main for-loop iteration:  259\n",
      "The currentNode is:  (7, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 7) in iteration:  259\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 7) is on the array\n",
      "neighborNode (6, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 7)\n",
      "index after cast:  [6, 7]\n",
      "Obtain cost of node: [ 6 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (6, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (7, 7) is:  26\n",
      "g cost of neighborNode:  (6, 7) plus its parentNode's:  (7, 7) g cost is:  31\n",
      "\n",
      "Main for-loop iteration:  260\n",
      "The currentNode is:  (7, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (7, 6) in iteration:  260\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 6) is on the array\n",
      "neighborNode (7, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 6)\n",
      "index after cast:  [7, 6]\n",
      "Obtain cost of node: [ 7 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 6) without adding parent cost is:  0\n",
      "g cost of parent node:  (7, 7) is:  26\n",
      "g cost of neighborNode:  (7, 6) plus its parentNode's:  (7, 7) g cost is:  26\n",
      "(7, 6) not pushed\n",
      "Current Node:  (8, 1)\n",
      "Unsuccessful goal check number:  66\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  261\n",
      "The currentNode is:  (8, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 2) in iteration:  261\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 2) is on the array\n",
      "neighborNode (8, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 2)\n",
      "index after cast:  [8, 2]\n",
      "Obtain cost of node: [ 8 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (8, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (8, 1) is:  33\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g cost of neighborNode:  (8, 2) plus its parentNode's:  (8, 1) g cost is:  33\n",
      "(8, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  262\n",
      "The currentNode is:  (8, 1)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 1) in iteration:  262\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 1) is on the array\n",
      "neighborNode (9, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 1)\n",
      "index after cast:  [9, 1]\n",
      "Obtain cost of node: [ 9 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (9, 1) without adding parent cost is:  4\n",
      "g cost of parent node:  (8, 1) is:  33\n",
      "g cost of neighborNode:  (9, 1) plus its parentNode's:  (8, 1) g cost is:  37\n",
      "(9, 1)  added to open list\n",
      "h of neighborNode:  (9, 1) is:  0\n",
      "f cost of neighborNode:  (9, 1) is:  37\n",
      "\n",
      "Main for-loop iteration:  263\n",
      "The currentNode is:  (8, 1)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 1) in iteration:  263\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 1) is on the array\n",
      "neighborNode (7, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 1)\n",
      "index after cast:  [7, 1]\n",
      "Obtain cost of node: [ 7 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (7, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (8, 1) is:  33\n",
      "g cost of neighborNode:  (7, 1) plus its parentNode's:  (8, 1) g cost is:  41\n",
      "\n",
      "Main for-loop iteration:  264\n",
      "The currentNode is:  (8, 1)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 0) in iteration:  264\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 0) is on the array\n",
      "neighborNode (8, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 0)\n",
      "index after cast:  [8, 0]\n",
      "Obtain cost of node: [ 8 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (8, 0) without adding parent cost is:  6\n",
      "g cost of parent node:  (8, 1) is:  33\n",
      "g cost of neighborNode:  (8, 0) plus its parentNode's:  (8, 1) g cost is:  39\n",
      "(8, 0)  added to open list\n",
      "h of neighborNode:  (8, 0) is:  2\n",
      "f cost of neighborNode:  (8, 0) is:  41\n",
      "Current Node:  (8, 3)\n",
      "Unsuccessful goal check number:  67\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  265\n",
      "The currentNode is:  (8, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 4) in iteration:  265\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 4) is on the array\n",
      "neighborNode (8, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 4)\n",
      "index after cast:  [8, 4]\n",
      "Obtain cost of node: [ 8 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (8, 4) without adding parent cost is:  2\n",
      "g cost of parent node:  (8, 3) is:  31\n",
      "g cost of neighborNode:  (8, 4) plus its parentNode's:  (8, 3) g cost is:  33\n",
      "(8, 4)  added to open list\n",
      "h of neighborNode:  (8, 4) is:  4\n",
      "f cost of neighborNode:  (8, 4) is:  37\n",
      "\n",
      "Main for-loop iteration:  266\n",
      "The currentNode is:  (8, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 3) in iteration:  266\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 3) is on the array\n",
      "neighborNode (9, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 3)\n",
      "index after cast:  [9, 3]\n",
      "Obtain cost of node: [ 9 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (9, 3) without adding parent cost is:  2\n",
      "g cost of parent node:  (8, 3) is:  31\n",
      "g cost of neighborNode:  (9, 3) plus its parentNode's:  (8, 3) g cost is:  33\n",
      "(9, 3)  added to open list\n",
      "h of neighborNode:  (9, 3) is:  2\n",
      "f cost of neighborNode:  (9, 3) is:  35\n",
      "\n",
      "Main for-loop iteration:  267\n",
      "The currentNode is:  (8, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 3) in iteration:  267\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 3) is on the array\n",
      "neighborNode (7, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 3)\n",
      "index after cast:  [7, 3]\n",
      "Obtain cost of node: [ 7 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (7, 3) without adding parent cost is:  0\n",
      "g cost of parent node:  (8, 3) is:  31\n",
      "g cost of neighborNode:  (7, 3) plus its parentNode's:  (8, 3) g cost is:  31\n",
      "(7, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  268\n",
      "The currentNode is:  (8, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 2) in iteration:  268\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 2) is on the array\n",
      "neighborNode (8, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 2)\n",
      "index after cast:  [8, 2]\n",
      "Obtain cost of node: [ 8 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (8, 2) without adding parent cost is:  0\n",
      "g cost of parent node:  (8, 3) is:  31\n",
      "g cost of neighborNode:  (8, 2) plus its parentNode's:  (8, 3) g cost is:  31\n",
      "(8, 2) not pushed\n",
      "Current Node:  (8, 7)\n",
      "Unsuccessful goal check number:  68\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  269\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 8) in iteration:  269\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 8) is on the array\n",
      "neighborNode (8, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 8)\n",
      "index after cast:  [8, 8]\n",
      "Obtain cost of node: [ 8 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (8, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (8, 8) plus its parentNode's:  (8, 7) g cost is:  36\n",
      "(8, 8)  added to open list\n",
      "h of neighborNode:  (8, 8) is:  8\n",
      "f cost of neighborNode:  (8, 8) is:  44\n",
      "\n",
      "Main for-loop iteration:  270\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 7) in iteration:  270\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 7) is on the array\n",
      "neighborNode (9, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 7)\n",
      "index after cast:  [9, 7]\n",
      "Obtain cost of node: [ 9 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (9, 7) without adding parent cost is:  9\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (9, 7) plus its parentNode's:  (8, 7) g cost is:  36\n",
      "(9, 7)  added to open list\n",
      "h of neighborNode:  (9, 7) is:  6\n",
      "f cost of neighborNode:  (9, 7) is:  42\n",
      "\n",
      "Main for-loop iteration:  271\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 7) in iteration:  271\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 7) is on the array\n",
      "neighborNode (7, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 7)\n",
      "index after cast:  [7, 7]\n",
      "Obtain cost of node: [ 7 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (7, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (7, 7) plus its parentNode's:  (8, 7) g cost is:  28\n",
      "(7, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  272\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 6) in iteration:  272\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 6) is on the array\n",
      "neighborNode (8, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 6)\n",
      "index after cast:  [8, 6]\n",
      "Obtain cost of node: [ 8 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (8, 6) without adding parent cost is:  2\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (8, 6) plus its parentNode's:  (8, 7) g cost is:  29\n",
      "(8, 6) not pushed\n",
      "Current Node:  (2, 2)\n",
      "Unsuccessful goal check number:  69\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  273\n",
      "The currentNode is:  (2, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 3) in iteration:  273\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 3) is on the array\n",
      "neighborNode (2, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 3)\n",
      "index after cast:  [2, 3]\n",
      "Obtain cost of node: [ 2 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (2, 3) without adding parent cost is:  8\n",
      "g cost of parent node:  (2, 2) is:  27\n",
      "g cost of neighborNode:  (2, 3) plus its parentNode's:  (2, 2) g cost is:  35\n",
      "(2, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  274\n",
      "The currentNode is:  (2, 2)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 2) in iteration:  274\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 2) is on the array\n",
      "neighborNode (3, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 2)\n",
      "index after cast:  [3, 2]\n",
      "Obtain cost of node: [ 3 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (3, 2) without adding parent cost is:  1\n",
      "g cost of parent node:  (2, 2) is:  27\n",
      "g cost of neighborNode:  (3, 2) plus its parentNode's:  (2, 2) g cost is:  28\n",
      "(3, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  275\n",
      "The currentNode is:  (2, 2)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 2) in iteration:  275\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 2) is on the array\n",
      "neighborNode (1, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 2)\n",
      "index after cast:  [1, 2]\n",
      "Obtain cost of node: [ 1 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (1, 2) without adding parent cost is:  5\n",
      "g cost of parent node:  (2, 2) is:  27\n",
      "g cost of neighborNode:  (1, 2) plus its parentNode's:  (2, 2) g cost is:  32\n",
      "(1, 2) not pushed\n",
      "\n",
      "Main for-loop iteration:  276\n",
      "The currentNode is:  (2, 2)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, 1) in iteration:  276\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 1) is on the array\n",
      "neighborNode (2, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 1)\n",
      "index after cast:  [2, 1]\n",
      "Obtain cost of node: [ 2 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (2, 2) is:  27\n",
      "g cost of neighborNode:  (2, 1) plus its parentNode's:  (2, 2) g cost is:  36\n",
      "Current Node:  (5, 9)\n",
      "Unsuccessful goal check number:  70\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  277\n",
      "The currentNode is:  (5, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 10) in iteration:  277\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(5, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  278\n",
      "The currentNode is:  (5, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 9) in iteration:  278\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 9) is on the array\n",
      "neighborNode (6, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 9)\n",
      "index after cast:  [6, 9]\n",
      "Obtain cost of node: [ 6 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (6, 9) without adding parent cost is:  2\n",
      "g cost of parent node:  (5, 9) is:  23\n",
      "g cost of neighborNode:  (6, 9) plus its parentNode's:  (5, 9) g cost is:  25\n",
      "(6, 9)  added to open list\n",
      "h of neighborNode:  (6, 9) is:  11\n",
      "f cost of neighborNode:  (6, 9) is:  36\n",
      "\n",
      "Main for-loop iteration:  279\n",
      "The currentNode is:  (5, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 9) in iteration:  279\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 9) is on the array\n",
      "neighborNode (4, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 9)\n",
      "index after cast:  [4, 9]\n",
      "Obtain cost of node: [ 4 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (4, 9) without adding parent cost is:  4\n",
      "g cost of parent node:  (5, 9) is:  23\n",
      "g cost of neighborNode:  (4, 9) plus its parentNode's:  (5, 9) g cost is:  27\n",
      "(4, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  280\n",
      "The currentNode is:  (5, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 8) in iteration:  280\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 8) is on the array\n",
      "neighborNode (5, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 8)\n",
      "index after cast:  [5, 8]\n",
      "Obtain cost of node: [ 5 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (5, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (5, 9) is:  23\n",
      "g cost of neighborNode:  (5, 8) plus its parentNode's:  (5, 9) g cost is:  32\n",
      "Current Node:  (6, 0)\n",
      "Unsuccessful goal check number:  71\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  281\n",
      "The currentNode is:  (6, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 1) in iteration:  281\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 1) is on the array\n",
      "neighborNode (6, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 1)\n",
      "index after cast:  [6, 1]\n",
      "Obtain cost of node: [ 6 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (6, 1) without adding parent cost is:  8\n",
      "g cost of parent node:  (6, 0) is:  31\n",
      "g cost of neighborNode:  (6, 1) plus its parentNode's:  (6, 0) g cost is:  39\n",
      "(6, 1) not pushed\n",
      "\n",
      "Main for-loop iteration:  282\n",
      "The currentNode is:  (6, 0)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 0) in iteration:  282\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 0) is on the array\n",
      "neighborNode (7, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 0)\n",
      "index after cast:  [7, 0]\n",
      "Obtain cost of node: [ 7 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (7, 0) without adding parent cost is:  8\n",
      "g cost of parent node:  (6, 0) is:  31\n",
      "g cost of neighborNode:  (7, 0) plus its parentNode's:  (6, 0) g cost is:  39\n",
      "(7, 0)  added to open list\n",
      "h of neighborNode:  (7, 0) is:  3\n",
      "f cost of neighborNode:  (7, 0) is:  42\n",
      "\n",
      "Main for-loop iteration:  283\n",
      "The currentNode is:  (6, 0)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 0) in iteration:  283\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 0) is on the array\n",
      "neighborNode (5, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 0)\n",
      "index after cast:  [5, 0]\n",
      "Obtain cost of node: [ 5 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (5, 0) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 0) is:  31\n",
      "g cost of neighborNode:  (5, 0) plus its parentNode's:  (6, 0) g cost is:  38\n",
      "\n",
      "Main for-loop iteration:  284\n",
      "The currentNode is:  (6, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, -1) in iteration:  284\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "(6, -1) :not on array\n",
      "Current Node:  (6, 4)\n",
      "Unsuccessful goal check number:  72\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  285\n",
      "The currentNode is:  (6, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 5) in iteration:  285\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 5) is on the array\n",
      "neighborNode (6, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 5)\n",
      "index after cast:  [6, 5]\n",
      "Obtain cost of node: [ 6 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "g cost of  neighborNode:  (6, 5) without adding parent cost is:  0\n",
      "g cost of parent node:  (6, 4) is:  29\n",
      "g cost of neighborNode:  (6, 5) plus its parentNode's:  (6, 4) g cost is:  29\n",
      "(6, 5) not pushed\n",
      "\n",
      "Main for-loop iteration:  286\n",
      "The currentNode is:  (6, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 4) in iteration:  286\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "checkNode:  (7, 4) is on the array\n",
      "neighborNode (7, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 4)\n",
      "index after cast:  [7, 4]\n",
      "Obtain cost of node: [ 7 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (7, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 4) is:  29\n",
      "g cost of neighborNode:  (7, 4) plus its parentNode's:  (6, 4) g cost is:  36\n",
      "\n",
      "Main for-loop iteration:  287\n",
      "The currentNode is:  (6, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 4) in iteration:  287\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 4) is on the array\n",
      "neighborNode (5, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 4)\n",
      "index after cast:  [5, 4]\n",
      "Obtain cost of node: [ 5 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 4) without adding parent cost is:  5\n",
      "g cost of parent node:  (6, 4) is:  29\n",
      "g cost of neighborNode:  (5, 4) plus its parentNode's:  (6, 4) g cost is:  34\n",
      "(5, 4) not pushed\n",
      "\n",
      "Main for-loop iteration:  288\n",
      "The currentNode is:  (6, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 3) in iteration:  288\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 3) is on the array\n",
      "neighborNode (6, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 3)\n",
      "index after cast:  [6, 3]\n",
      "Obtain cost of node: [ 6 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (6, 3) without adding parent cost is:  7\n",
      "g cost of parent node:  (6, 4) is:  29\n",
      "g cost of neighborNode:  (6, 3) plus its parentNode's:  (6, 4) g cost is:  36\n",
      "(6, 3) not pushed\n",
      "Current Node:  (8, 7)\n",
      "Unsuccessful goal check number:  73\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  289\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 8) in iteration:  289\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 8) is on the array\n",
      "neighborNode (8, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 8)\n",
      "index after cast:  [8, 8]\n",
      "Obtain cost of node: [ 8 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (8, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (8, 8) plus its parentNode's:  (8, 7) g cost is:  36\n",
      "\n",
      "Main for-loop iteration:  290\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 7) in iteration:  290\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 7) is on the array\n",
      "neighborNode (9, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 7)\n",
      "index after cast:  [9, 7]\n",
      "Obtain cost of node: [ 9 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (9, 7) without adding parent cost is:  9\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (9, 7) plus its parentNode's:  (8, 7) g cost is:  36\n",
      "\n",
      "Main for-loop iteration:  291\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 7) in iteration:  291\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 7) is on the array\n",
      "neighborNode (7, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 7)\n",
      "index after cast:  [7, 7]\n",
      "Obtain cost of node: [ 7 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (7, 7) without adding parent cost is:  1\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (7, 7) plus its parentNode's:  (8, 7) g cost is:  28\n",
      "(7, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  292\n",
      "The currentNode is:  (8, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 6) in iteration:  292\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 6) is on the array\n",
      "neighborNode (8, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 6)\n",
      "index after cast:  [8, 6]\n",
      "Obtain cost of node: [ 8 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (8, 6) without adding parent cost is:  2\n",
      "g cost of parent node:  (8, 7) is:  27\n",
      "g cost of neighborNode:  (8, 6) plus its parentNode's:  (8, 7) g cost is:  29\n",
      "(8, 6) not pushed\n",
      "Current Node:  (9, 3)\n",
      "Unsuccessful goal check number:  74\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  293\n",
      "The currentNode is:  (9, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (9, 4) in iteration:  293\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 4) is on the array\n",
      "neighborNode (9, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 4)\n",
      "index after cast:  [9, 4]\n",
      "Obtain cost of node: [ 9 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (9, 4) without adding parent cost is:  4\n",
      "g cost of parent node:  (9, 3) is:  33\n",
      "g cost of neighborNode:  (9, 4) plus its parentNode's:  (9, 3) g cost is:  37\n",
      "(9, 4)  added to open list\n",
      "h of neighborNode:  (9, 4) is:  3\n",
      "f cost of neighborNode:  (9, 4) is:  40\n",
      "\n",
      "Main for-loop iteration:  294\n",
      "The currentNode is:  (9, 3)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (10, 3) in iteration:  294\n",
      "Check 1 passed\n",
      "(10, 3) :not on array\n",
      "\n",
      "Main for-loop iteration:  295\n",
      "The currentNode is:  (9, 3)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 3) in iteration:  295\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 3) is on the array\n",
      "neighborNode (8, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 3)\n",
      "index after cast:  [8, 3]\n",
      "Obtain cost of node: [ 8 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (8, 3) without adding parent cost is:  4\n",
      "g cost of parent node:  (9, 3) is:  33\n",
      "g cost of neighborNode:  (8, 3) plus its parentNode's:  (9, 3) g cost is:  37\n",
      "(8, 3) not pushed\n",
      "\n",
      "Main for-loop iteration:  296\n",
      "The currentNode is:  (9, 3)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (9, 2) in iteration:  296\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 2) is on the array\n",
      "neighborNode (9, 2) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 2)\n",
      "index after cast:  [9, 2]\n",
      "Obtain cost of node: [ 9 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (9, 2) without adding parent cost is:  8\n",
      "g cost of parent node:  (9, 3) is:  33\n",
      "g cost of neighborNode:  (9, 2) plus its parentNode's:  (9, 3) g cost is:  41\n",
      "Current Node:  (9, 6)\n",
      "Unsuccessful goal check number:  75\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  297\n",
      "The currentNode is:  (9, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (9, 7) in iteration:  297\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 7) is on the array\n",
      "neighborNode (9, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 7)\n",
      "index after cast:  [9, 7]\n",
      "Obtain cost of node: [ 9 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (9, 7) without adding parent cost is:  9\n",
      "g cost of parent node:  (9, 6) is:  30\n",
      "g cost of neighborNode:  (9, 7) plus its parentNode's:  (9, 6) g cost is:  39\n",
      "\n",
      "Main for-loop iteration:  298\n",
      "The currentNode is:  (9, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (10, 6) in iteration:  298\n",
      "Check 1 passed\n",
      "(10, 6) :not on array\n",
      "\n",
      "Main for-loop iteration:  299\n",
      "The currentNode is:  (9, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 6) in iteration:  299\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 6) is on the array\n",
      "neighborNode (8, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 6)\n",
      "index after cast:  [8, 6]\n",
      "Obtain cost of node: [ 8 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (8, 6) without adding parent cost is:  2\n",
      "g cost of parent node:  (9, 6) is:  30\n",
      "g cost of neighborNode:  (8, 6) plus its parentNode's:  (9, 6) g cost is:  32\n",
      "(8, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  300\n",
      "The currentNode is:  (9, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (9, 5) in iteration:  300\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 5) is on the array\n",
      "neighborNode (9, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 5)\n",
      "index after cast:  [9, 5]\n",
      "Obtain cost of node: [ 9 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "g cost of  neighborNode:  (9, 5) without adding parent cost is:  2\n",
      "g cost of parent node:  (9, 6) is:  30\n",
      "g cost of neighborNode:  (9, 5) plus its parentNode's:  (9, 6) g cost is:  32\n",
      "(9, 5)  added to open list\n",
      "h of neighborNode:  (9, 5) is:  4\n",
      "f cost of neighborNode:  (9, 5) is:  36\n",
      "Current Node:  (5, 7)\n",
      "Unsuccessful goal check number:  76\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (5, 7), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  301\n",
      "The currentNode is:  (5, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 8) in iteration:  301\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 8) is on the array\n",
      "neighborNode (5, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 8)\n",
      "index after cast:  [5, 8]\n",
      "Obtain cost of node: [ 5 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (5, 8) without adding parent cost is:  9\n",
      "g cost of parent node:  (5, 7) is:  26\n",
      "g cost of neighborNode:  (5, 8) plus its parentNode's:  (5, 7) g cost is:  35\n",
      "\n",
      "Main for-loop iteration:  302\n",
      "The currentNode is:  (5, 7)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 7) in iteration:  302\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 7) is on the array\n",
      "neighborNode (6, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 7)\n",
      "index after cast:  [6, 7]\n",
      "Obtain cost of node: [ 6 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (6, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 7) is:  26\n",
      "g cost of neighborNode:  (6, 7) plus its parentNode's:  (5, 7) g cost is:  31\n",
      "\n",
      "Main for-loop iteration:  303\n",
      "The currentNode is:  (5, 7)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 7) in iteration:  303\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 7) is on the array\n",
      "neighborNode (4, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 7)\n",
      "index after cast:  [4, 7]\n",
      "Obtain cost of node: [ 4 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (4, 7) without adding parent cost is:  7\n",
      "g cost of parent node:  (5, 7) is:  26\n",
      "g cost of neighborNode:  (4, 7) plus its parentNode's:  (5, 7) g cost is:  33\n",
      "(4, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  304\n",
      "The currentNode is:  (5, 7)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 6) in iteration:  304\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 6) is on the array\n",
      "neighborNode (5, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 6)\n",
      "index after cast:  [5, 6]\n",
      "Obtain cost of node: [ 5 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (5, 6) without adding parent cost is:  8\n",
      "g cost of parent node:  (5, 7) is:  26\n",
      "g cost of neighborNode:  (5, 6) plus its parentNode's:  (5, 7) g cost is:  34\n",
      "Current Node:  (6, 9)\n",
      "Unsuccessful goal check number:  77\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (6, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (5, 7), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  305\n",
      "The currentNode is:  (6, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (6, 10) in iteration:  305\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "(6, 10) :not on array\n",
      "\n",
      "Main for-loop iteration:  306\n",
      "The currentNode is:  (6, 9)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 9) in iteration:  306\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 9) is on the array\n",
      "neighborNode (7, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 9)\n",
      "index after cast:  [7, 9]\n",
      "Obtain cost of node: [ 7 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (7, 9) without adding parent cost is:  5\n",
      "g cost of parent node:  (6, 9) is:  25\n",
      "g cost of neighborNode:  (7, 9) plus its parentNode's:  (6, 9) g cost is:  30\n",
      "(7, 9)  added to open list\n",
      "h of neighborNode:  (7, 9) is:  10\n",
      "f cost of neighborNode:  (7, 9) is:  40\n",
      "\n",
      "Main for-loop iteration:  307\n",
      "The currentNode is:  (6, 9)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (5, 9) in iteration:  307\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 9) is on the array\n",
      "neighborNode (5, 9) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 9)\n",
      "index after cast:  [5, 9]\n",
      "Obtain cost of node: [ 5 9 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (5, 9) without adding parent cost is:  6\n",
      "g cost of parent node:  (6, 9) is:  25\n",
      "g cost of neighborNode:  (5, 9) plus its parentNode's:  (6, 9) g cost is:  31\n",
      "(5, 9) not pushed\n",
      "\n",
      "Main for-loop iteration:  308\n",
      "The currentNode is:  (6, 9)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (6, 8) in iteration:  308\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 8) is on the array\n",
      "neighborNode (6, 8) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 8)\n",
      "index after cast:  [6, 8]\n",
      "Obtain cost of node: [ 6 8 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (6, 8) without adding parent cost is:  3\n",
      "g cost of parent node:  (6, 9) is:  25\n",
      "g cost of neighborNode:  (6, 8) plus its parentNode's:  (6, 9) g cost is:  28\n",
      "(6, 8)  added to open list\n",
      "h of neighborNode:  (6, 8) is:  10\n",
      "f cost of neighborNode:  (6, 8) is:  38\n",
      "Current Node:  (9, 5)\n",
      "Unsuccessful goal check number:  78\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (6, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (5, 7), (3, 8), (0, 6), (1, 8), (4, 3), (1, 7), (0, 9), (9, 5), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  309\n",
      "The currentNode is:  (9, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (9, 6) in iteration:  309\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 6) is on the array\n",
      "neighborNode (9, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 6)\n",
      "index after cast:  [9, 6]\n",
      "Obtain cost of node: [ 9 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (9, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (9, 5) is:  32\n",
      "g cost of neighborNode:  (9, 6) plus its parentNode's:  (9, 5) g cost is:  35\n",
      "(9, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  310\n",
      "The currentNode is:  (9, 5)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (10, 5) in iteration:  310\n",
      "Check 1 passed\n",
      "(10, 5) :not on array\n",
      "\n",
      "Main for-loop iteration:  311\n",
      "The currentNode is:  (9, 5)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (8, 5) in iteration:  311\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 5) is on the array\n",
      "neighborNode (8, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 5)\n",
      "index after cast:  [8, 5]\n",
      "Obtain cost of node: [ 8 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (8, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (9, 5) is:  32\n",
      "g cost of neighborNode:  (8, 5) plus its parentNode's:  (9, 5) g cost is:  38\n",
      "\n",
      "Main for-loop iteration:  312\n",
      "The currentNode is:  (9, 5)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (9, 4) in iteration:  312\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 4) is on the array\n",
      "neighborNode (9, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 4)\n",
      "index after cast:  [9, 4]\n",
      "Obtain cost of node: [ 9 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (9, 4) without adding parent cost is:  4\n",
      "g cost of parent node:  (9, 5) is:  32\n",
      "g cost of neighborNode:  (9, 4) plus its parentNode's:  (9, 5) g cost is:  36\n",
      "(9, 4)  added to open list\n",
      "h of neighborNode:  (9, 4) is:  3\n",
      "f cost of neighborNode:  (9, 4) is:  39\n",
      "Current Node:  (2, 0)\n",
      "Unsuccessful goal check number:  79\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (6, 9), (4, 8), (6, 6), (0, 2), (2, 8), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (5, 7), (3, 8), (0, 6), (1, 8), (2, 0), (4, 3), (1, 7), (0, 9), (9, 5), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  313\n",
      "The currentNode is:  (2, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (2, 1) in iteration:  313\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (2, 1) is on the array\n",
      "neighborNode (2, 1) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 1)\n",
      "index after cast:  [2, 1]\n",
      "Obtain cost of node: [ 2 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "g cost of  neighborNode:  (2, 1) without adding parent cost is:  9\n",
      "g cost of parent node:  (2, 0) is:  29\n",
      "g cost of neighborNode:  (2, 1) plus its parentNode's:  (2, 0) g cost is:  38\n",
      "\n",
      "Main for-loop iteration:  314\n",
      "The currentNode is:  (2, 0)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (3, 0) in iteration:  314\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (3, 0) is on the array\n",
      "neighborNode (3, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 0)\n",
      "index after cast:  [3, 0]\n",
      "Obtain cost of node: [ 3 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  8\n",
      "g cost of  neighborNode:  (3, 0) without adding parent cost is:  8\n",
      "g cost of parent node:  (2, 0) is:  29\n",
      "g cost of neighborNode:  (3, 0) plus its parentNode's:  (2, 0) g cost is:  37\n",
      "\n",
      "Main for-loop iteration:  315\n",
      "The currentNode is:  (2, 0)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (1, 0) in iteration:  315\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (1, 0) is on the array\n",
      "neighborNode (1, 0) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 0)\n",
      "index after cast:  [1, 0]\n",
      "Obtain cost of node: [ 1 0 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (1, 0) without adding parent cost is:  1\n",
      "g cost of parent node:  (2, 0) is:  29\n",
      "g cost of neighborNode:  (1, 0) plus its parentNode's:  (2, 0) g cost is:  30\n",
      "(1, 0) not pushed\n",
      "\n",
      "Main for-loop iteration:  316\n",
      "The currentNode is:  (2, 0)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (2, -1) in iteration:  316\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "(2, -1) :not on array\n",
      "Current Node:  (5, 6)\n",
      "Unsuccessful goal check number:  80\n",
      "Closed Nodes:  {(7, 3), (4, 7), (1, 3), (5, 9), (6, 9), (4, 8), (6, 6), (0, 2), (2, 8), (5, 6), (7, 7), (0, 7), (6, 2), (1, 6), (3, 7), (2, 5), (0, 3), (5, 1), (7, 2), (4, 0), (1, 2), (4, 9), (3, 3), (2, 9), (5, 5), (8, 1), (7, 6), (4, 4), (6, 3), (1, 5), (3, 6), (0, 4), (2, 2), (8, 6), (4, 1), (1, 1), (6, 4), (3, 2), (2, 6), (5, 4), (8, 2), (4, 5), (9, 3), (5, 2), (6, 0), (1, 4), (3, 9), (0, 5), (1, 9), (2, 3), (7, 5), (8, 7), (4, 2), (1, 0), (0, 8), (9, 6), (6, 5), (3, 5), (2, 7), (0, 1), (5, 3), (8, 3), (4, 6), (6, 1), (3, 1), (5, 7), (3, 8), (0, 6), (1, 8), (2, 0), (4, 3), (1, 7), (0, 9), (9, 5), (3, 4), (2, 4)}\n",
      "\n",
      "Main for-loop iteration:  317\n",
      "The currentNode is:  (5, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (5, 7) in iteration:  317\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 7) is on the array\n",
      "neighborNode (5, 7) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 7)\n",
      "index after cast:  [5, 7]\n",
      "Obtain cost of node: [ 5 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "g cost of  neighborNode:  (5, 7) without adding parent cost is:  5\n",
      "g cost of parent node:  (5, 6) is:  28\n",
      "g cost of neighborNode:  (5, 7) plus its parentNode's:  (5, 6) g cost is:  33\n",
      "(5, 7) not pushed\n",
      "\n",
      "Main for-loop iteration:  318\n",
      "The currentNode is:  (5, 6)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (6, 6) in iteration:  318\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (6, 6) is on the array\n",
      "neighborNode (6, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 6)\n",
      "index after cast:  [6, 6]\n",
      "Obtain cost of node: [ 6 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "g cost of  neighborNode:  (6, 6) without adding parent cost is:  3\n",
      "g cost of parent node:  (5, 6) is:  28\n",
      "g cost of neighborNode:  (6, 6) plus its parentNode's:  (5, 6) g cost is:  31\n",
      "(6, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  319\n",
      "The currentNode is:  (5, 6)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (4, 6) in iteration:  319\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (4, 6) is on the array\n",
      "neighborNode (4, 6) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 6)\n",
      "index after cast:  [4, 6]\n",
      "Obtain cost of node: [ 4 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (4, 6) without adding parent cost is:  1\n",
      "g cost of parent node:  (5, 6) is:  28\n",
      "g cost of neighborNode:  (4, 6) plus its parentNode's:  (5, 6) g cost is:  29\n",
      "(4, 6) not pushed\n",
      "\n",
      "Main for-loop iteration:  320\n",
      "The currentNode is:  (5, 6)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (5, 5) in iteration:  320\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (5, 5) is on the array\n",
      "neighborNode (5, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 5)\n",
      "index after cast:  [5, 5]\n",
      "Obtain cost of node: [ 5 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "g cost of  neighborNode:  (5, 5) without adding parent cost is:  1\n",
      "g cost of parent node:  (5, 6) is:  28\n",
      "g cost of neighborNode:  (5, 5) plus its parentNode's:  (5, 6) g cost is:  29\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5) not pushed\n",
      "Current Node:  (8, 4)\n",
      "Unsuccessful goal check number:  81\n",
      "Closed Nodes:  {(7, 3), (6, 9), (0, 7), (1, 6), (3, 7), (2, 5), (4, 0), (5, 5), (7, 6), (0, 4), (1, 1), (3, 2), (2, 6), (8, 2), (4, 5), (9, 3), (6, 0), (7, 5), (0, 1), (3, 1), (5, 1), (7, 2), (1, 5), (3, 6), (2, 2), (8, 6), (4, 1), (6, 4), (5, 4), (0, 5), (1, 0), (0, 8), (3, 5), (2, 7), (8, 3), (4, 6), (6, 1), (5, 7), (0, 2), (1, 3), (4, 8), (2, 8), (6, 2), (1, 4), (3, 9), (2, 3), (1, 9), (8, 7), (4, 2), (9, 6), (6, 5), (5, 3), (0, 6), (1, 7), (0, 9), (3, 4), (2, 4), (8, 4), (5, 9), (4, 7), (6, 6), (5, 6), (7, 7), (0, 3), (1, 2), (4, 9), (3, 3), (2, 9), (8, 1), (4, 4), (6, 3), (3, 8), (2, 0), (1, 8), (4, 3), (9, 5), (5, 2)}\n",
      "\n",
      "Main for-loop iteration:  321\n",
      "The currentNode is:  (8, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : 1\n",
      "This is checkNode:  (8, 5) in iteration:  321\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 5) is on the array\n",
      "neighborNode (8, 5) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 5)\n",
      "index after cast:  [8, 5]\n",
      "Obtain cost of node: [ 8 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  6\n",
      "g cost of  neighborNode:  (8, 5) without adding parent cost is:  6\n",
      "g cost of parent node:  (8, 4) is:  33\n",
      "g cost of neighborNode:  (8, 5) plus its parentNode's:  (8, 4) g cost is:  39\n",
      "\n",
      "Main for-loop iteration:  322\n",
      "The currentNode is:  (8, 4)\n",
      "[0] value in adjacentNode list:  1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (9, 4) in iteration:  322\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (9, 4) is on the array\n",
      "neighborNode (9, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 4)\n",
      "index after cast:  [9, 4]\n",
      "Obtain cost of node: [ 9 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (9, 4) without adding parent cost is:  4\n",
      "g cost of parent node:  (8, 4) is:  33\n",
      "g cost of neighborNode:  (9, 4) plus its parentNode's:  (8, 4) g cost is:  37\n",
      "\n",
      "Main for-loop iteration:  323\n",
      "The currentNode is:  (8, 4)\n",
      "[0] value in adjacentNode list:  -1\n",
      "[1] value in adjacentnode list : 0\n",
      "This is checkNode:  (7, 4) in iteration:  323\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (7, 4) is on the array\n",
      "neighborNode (7, 4) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 4)\n",
      "index after cast:  [7, 4]\n",
      "Obtain cost of node: [ 7 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  7\n",
      "g cost of  neighborNode:  (7, 4) without adding parent cost is:  7\n",
      "g cost of parent node:  (8, 4) is:  33\n",
      "g cost of neighborNode:  (7, 4) plus its parentNode's:  (8, 4) g cost is:  40\n",
      "\n",
      "Main for-loop iteration:  324\n",
      "The currentNode is:  (8, 4)\n",
      "[0] value in adjacentNode list:  0\n",
      "[1] value in adjacentnode list : -1\n",
      "This is checkNode:  (8, 3) in iteration:  324\n",
      "Check 1 passed\n",
      "Check 2 passed\n",
      "Check 3 passed\n",
      "checkNode:  (8, 3) is on the array\n",
      "neighborNode (8, 3) has taken the value of checkNode\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 3)\n",
      "index after cast:  [8, 3]\n",
      "Obtain cost of node: [ 8 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "g cost of  neighborNode:  (8, 3) without adding parent cost is:  4\n",
      "g cost of parent node:  (8, 4) is:  33\n",
      "g cost of neighborNode:  (8, 3) plus its parentNode's:  (8, 4) g cost is:  37\n",
      "(8, 3) not pushed\n",
      "Current Node:  (9, 1)\n",
      "Goal has been reached\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (9, 1)\n",
      "index after cast:  [9, 1]\n",
      "Obtain cost of node: [ 9 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "(9, 1)  g is cost of current node:  4 , + cost of parent node,total is:  37  h cost is:  0  and f cost is:  37\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 1)\n",
      "index after cast:  [8, 1]\n",
      "Obtain cost of node: [ 8 1 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  4\n",
      "(8, 1)  g is cost of current node:  4 , + cost of parent node,total is:  33  h cost is:  1  and f cost is:  34\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (8, 2)\n",
      "index after cast:  [8, 2]\n",
      "Obtain cost of node: [ 8 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "(8, 2)  g is cost of current node:  0 , + cost of parent node,total is:  29  h cost is:  2  and f cost is:  31\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (7, 2)\n",
      "index after cast:  [7, 2]\n",
      "Obtain cost of node: [ 7 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  9\n",
      "(7, 2)  g is cost of current node:  9 , + cost of parent node,total is:  29  h cost is:  3  and f cost is:  32\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (6, 2)\n",
      "index after cast:  [6, 2]\n",
      "Obtain cost of node: [ 6 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "(6, 2)  g is cost of current node:  0 , + cost of parent node,total is:  20  h cost is:  4  and f cost is:  24\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (5, 2)\n",
      "index after cast:  [5, 2]\n",
      "Obtain cost of node: [ 5 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "(5, 2)  g is cost of current node:  0 , + cost of parent node,total is:  20  h cost is:  5  and f cost is:  25\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (4, 2)\n",
      "index after cast:  [4, 2]\n",
      "Obtain cost of node: [ 4 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "(4, 2)  g is cost of current node:  2 , + cost of parent node,total is:  20  h cost is:  6  and f cost is:  26\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 2)\n",
      "index after cast:  [3, 2]\n",
      "Obtain cost of node: [ 3 2 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "(3, 2)  g is cost of current node:  1 , + cost of parent node,total is:  18  h cost is:  7  and f cost is:  25\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 3)\n",
      "index after cast:  [3, 3]\n",
      "Obtain cost of node: [ 3 3 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "(3, 3)  g is cost of current node:  2 , + cost of parent node,total is:  17  h cost is:  8  and f cost is:  25\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (3, 4)\n",
      "index after cast:  [3, 4]\n",
      "Obtain cost of node: [ 3 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "(3, 4)  g is cost of current node:  2 , + cost of parent node,total is:  15  h cost is:  9  and f cost is:  24\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (2, 4)\n",
      "index after cast:  [2, 4]\n",
      "Obtain cost of node: [ 2 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  0\n",
      "(2, 4)  g is cost of current node:  0 , + cost of parent node,total is:  13  h cost is:  10  and f cost is:  23\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 4)\n",
      "index after cast:  [1, 4]\n",
      "Obtain cost of node: [ 1 4 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "(1, 4)  g is cost of current node:  2 , + cost of parent node,total is:  13  h cost is:  11  and f cost is:  24\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 5)\n",
      "index after cast:  [1, 5]\n",
      "Obtain cost of node: [ 1 5 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  2\n",
      "(1, 5)  g is cost of current node:  2 , + cost of parent node,total is:  11  h cost is:  12  and f cost is:  23\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 6)\n",
      "index after cast:  [1, 6]\n",
      "Obtain cost of node: [ 1 6 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  3\n",
      "(1, 6)  g is cost of current node:  3 , + cost of parent node,total is:  9  h cost is:  13  and f cost is:  22\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (1, 7)\n",
      "index after cast:  [1, 7]\n",
      "Obtain cost of node: [ 1 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  5\n",
      "(1, 7)  g is cost of current node:  5 , + cost of parent node,total is:  6  h cost is:  14  and f cost is:  20\n",
      "\n",
      "function call to cost evaluation:\n",
      "index:  (0, 7)\n",
      "index after cast:  [0, 7]\n",
      "Obtain cost of node: [ 0 7 ] from numpy array cost matrix\n",
      "\n",
      "\n",
      "gVal:  1\n",
      "(0, 7)  g is cost of current node:  1 , + cost of parent node,total is:  1  h cost is:  15  and f cost is:  16\n",
      "Astar took 15.473510503768921 to run\n",
      "Path to goal is:  [(0, 7), (1, 7), (1, 6), (1, 5), (1, 4), (2, 4), (3, 4), (3, 3), (3, 2), (4, 2), (5, 2), (6, 2), (7, 2), (8, 2), (8, 1), (9, 1)]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "from heapq import *\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import widgets\n",
    "#btn=widgets.Button(description=\"Run ASTAR\")\n",
    "#display(btn)\n",
    "# cost matrix as a numpy array\n",
    "start_time = time.time()\n",
    "cost = np.random.seed(6)\n",
    "cost = np.random.randint(10, size=(20, 20),)\n",
    "\n",
    "#print(cost)\n",
    "#imgplot=plt.imshow(cost)\n",
    "#print test of cost matrix and specific index in numpy array\n",
    "#print(cost)\n",
    "#print(cost[9,6])\n",
    "# create the problem grid a rows and b columns\n",
    "searchArea = [] \n",
    "def createGrid(a,b):\n",
    "    for x in range(a):\n",
    "        for y in range(b):\n",
    "            searchArea.append([x, y])\n",
    "#print test of grid        \n",
    "#print(grid)\n",
    "\n",
    "# expansion function to find adjacent neighbors of current node, can move vertical and horizontal so four directions are needed\n",
    "#must also only move within the grid\n",
    "def expand(node): \n",
    "    adjacentNodes = [[1, 0], [0, 1], [-1, 0], [0, -1]]\n",
    "    result = []\n",
    "    for adjacent in adjacentNodes:\n",
    "        neighbor = [node[0] + adjacent[0], node[1] + adjacent[1]]\n",
    "        if neighbor in grid:\n",
    "            result.append(neighbor)\n",
    "    return result\n",
    "def heuristic(first, second): # first = current node, second = goal node first and second are two index tuples\n",
    "    return abs(second[0] - first[0]) + abs(second[1] - first[1])\n",
    "#def evaluation(neighborNode, end):\n",
    "def evaluation(eNode):\n",
    "    #create a copy of enode, pull values out of copy and assign to valiables i, j\n",
    "    #pass i, j to slice cost numpy array for cost value of node\n",
    "    print()\n",
    "    print(\"function call to cost evaluation:\")\n",
    "    index = eNode[:]\n",
    "    print(\"index: \",  index)\n",
    "    #print(index)\n",
    "    #cast the tuple index into a list so that the values can be interated and popped\n",
    "    index = list(index)\n",
    "    print(\"index after cast: \", index)\n",
    "    while len(index)>0:\n",
    "        indexI = index.pop(0)\n",
    "        i = indexI\n",
    "        indexJ = index.pop(0)\n",
    "        j = indexJ\n",
    "    print(\"Obtain cost of node: [\", i,j, \"] from numpy array cost matrix\" )\n",
    "    #print(i,j)\n",
    "    print()\n",
    "    #hValue = heuristic(eNode, end)\n",
    "    # cannot use cost() must use cost[], using () makes python interpret as a function call\n",
    "    \n",
    "    gVal = cost[i,j] #+ parentNodeG\n",
    "    #fValue = hValue + gValue\n",
    "    \n",
    "    #print(\"hValue:\")\n",
    "    #print(hValue)\n",
    "    print()\n",
    "    print(\"gVal: \", + gVal)\n",
    "    \n",
    "    #print()\n",
    "    #print(\"fValue\")\n",
    "    #print(fValue)\n",
    "    #print()\n",
    "    #return fValue\n",
    "    return gVal\n",
    "\n",
    "  \n",
    "def onclickGrid(b):\n",
    "    r = int(text1.value)\n",
    "    c = int(text2.value)\n",
    "    createGrid(r,c)\n",
    "    print(\"After creating the grid space click the Run ASTAR button\")\n",
    "    \n",
    "# astar function,  \n",
    "def onclick(b):\n",
    "    \n",
    "    \n",
    "    astarPath(grid, (0,8), (9,1))\n",
    "    \n",
    "   \n",
    "                        \n",
    "    \n",
    "def astarPath(grid, start, goal):\n",
    "    #declare an open list that will be turned into a heap for popping the smallest f Value\n",
    "    openList = []\n",
    "    #declare a dictionary to hold a node's parent\n",
    "    parentNode = {}\n",
    "    #sets are quicker than lists, declare a set for the closed nodes\n",
    "    closedNodes = set()\n",
    "    gCheck = 1\n",
    "    #frontier = []\n",
    "    #seenList = []\n",
    "    #declare a dictionary to hold the g values\n",
    "    gValue = {start:0}\n",
    "    #declare a dictionary to hold the f values\n",
    "    \n",
    "    fValue = {start:heuristic(start,goal)}\n",
    "    \n",
    "    #values for expnsion to find adjancent nodes to current node\n",
    "    adjacentNodes = [[0, 1], [1, 0], [-1, 0], [0, -1]]\n",
    "    #variables for iteration of main for loop\n",
    "    i=1\n",
    "    r = 1\n",
    "    # turn the openList into a heap and place the starting node and its fValue, as a tuple, on the heap\n",
    "    heappush(openList, (fValue[start], start))\n",
    "    while openList:\n",
    "        #set current node by:\n",
    "        #heappop the node from the openList heap, use [1] so that currentNode will only take the node\n",
    "        #not the node and its fValue\n",
    "        \n",
    "        currentNode = heappop(openList)[1]\n",
    "        print(\"Current Node: \", currentNode)\n",
    "        #print()\n",
    "        \n",
    "        #goal check\n",
    "        if currentNode == goal:\n",
    "            print(\"Goal has been reached\")\n",
    "            nodePath = []\n",
    "            while currentNode in parentNode:\n",
    "                nVal = evaluation(currentNode)\n",
    "                print(currentNode,\" g is cost of current node: \",nVal,\", + cost of parent node,total is: \" ,gValue[currentNode],\" h cost is: \",heuristic(currentNode, goal), \" and f cost is: \",fValue[currentNode]  )\n",
    "                nodePath.append(currentNode)\n",
    "                currentNode = parentNode[currentNode]\n",
    "            print(\"Astar took\", time.time() - start_time, \"to run\")     \n",
    "            print(\"Path to goal is: \", nodePath[::-1])\n",
    "            \n",
    "            return nodePath[::-1]\n",
    "            \n",
    "            #print(\"Path to goal is: \", nodePath)\n",
    "             #while len(nodePath)>0:\n",
    "                    #node = nodePath.pop(0)\n",
    "                    \n",
    "                    \n",
    "        else:\n",
    "            print(\"Unsuccessful goal check number: \", gCheck)\n",
    "            gCheck += 1\n",
    "            \n",
    "        #add the current node to the closed set    \n",
    "            closedNodes.add(currentNode)\n",
    "            print(\"Closed Nodes: \", closedNodes)\n",
    "        # declare for loop to find adjacent nodes to current node\n",
    "        # a, b are [0] and [1] in the 4 directions of movement\n",
    "        for a, b in adjacentNodes:\n",
    "            print()\n",
    "            print(\"Main for-loop iteration: \", i)\n",
    "            print(\"The currentNode is: \", currentNode)\n",
    "            print(\"[0] value in adjacentNode list: \", a)\n",
    "           \n",
    "            print(\"[1] value in adjacentnode list :\" , b)\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "           \n",
    "            #declare variable checkNode to hold newly created node to see if it's on the array\n",
    "            checkNode = currentNode[0] + a, currentNode[1] + b\n",
    "            \n",
    "            print(\"This is checkNode: \",checkNode, \"in iteration: \", r)\n",
    "           \n",
    "            i+=1\n",
    "            r+=1\n",
    "            if 0 <= checkNode[0]:\n",
    "                print(\"Check 1 passed\")\n",
    "                if 9 >= checkNode[0]:\n",
    "                    print(\"Check 2 passed\")\n",
    "                    if 0 <= checkNode[1]:\n",
    "                        print(\"Check 3 passed\")\n",
    "                   \n",
    "                        if 9 >=checkNode[1]:\n",
    "                            print(\"checkNode: \", checkNode, \"is on the array\")\n",
    "                            #print(\"checkNode:\", checkNode)\n",
    "                            neighborNode = checkNode\n",
    "                            print(\"neighborNode\", neighborNode, \"has taken the value of checkNode\")\n",
    "                            gVal = evaluation(neighborNode)\n",
    "                            print(\"g cost of  neighborNode: \", neighborNode, \"without adding parent cost is: \", gVal)\n",
    "                            tempGValue = gValue[currentNode] + gVal\n",
    "                            print(\"g cost of parent node: \", currentNode, \"is: \",gValue[currentNode] )\n",
    "                            print(\"g cost of neighborNode: \", neighborNode, \"plus its parentNode's: \", currentNode, \"g cost is: \", tempGValue)\n",
    "                            # if the neighborNode is in the closed set and its g value is greater\n",
    "                            #than the same node in the closedset do not put it in the closedset and keep going\n",
    "                            if neighborNode in closedNodes and tempGValue >= gValue.get(neighborNode, 0):\n",
    "                                print(neighborNode, 'not pushed')\n",
    "                                continue\n",
    "                            # check to see if the neighborNode already has a value listed in the g value dict\n",
    "                            # if it doesn't reurn zero, if the new temp g value is less than the existing value \n",
    "                            #or if if it isn't first on the openList heap then perform the following:\n",
    "                            if tempGValue < gValue.get(neighborNode, 0) or neighborNode not in [nNode[1] for nNode in openList]:\n",
    "                                parentNode[neighborNode] = currentNode\n",
    "                                gValue[neighborNode] = tempGValue\n",
    "                                fValue[neighborNode] = tempGValue + heuristic(neighborNode, goal)\n",
    "                                h =  heuristic(neighborNode, goal)\n",
    "                                heappush(openList, (fValue[neighborNode], neighborNode))\n",
    "                                print(neighborNode, \" added to open list\")\n",
    "                                print(\"h of neighborNode: \", neighborNode, \"is: \",h )\n",
    "                                print(\"f cost of neighborNode: \", neighborNode, \"is: \",fValue[neighborNode] )\n",
    "                        else:\n",
    "                            print(checkNode, \":not on array\")\n",
    "                            continue \n",
    "                    \n",
    "                    \n",
    "                    else:\n",
    "                        print(checkNode, \":not on array\")\n",
    "                        continue       \n",
    "                else:\n",
    "                    print(checkNode, \":not on array\")\n",
    "                    continue         \n",
    "                                \n",
    "            else:\n",
    "                print(checkNode, \":not on array\")\n",
    "                continue                \n",
    "                        \n",
    "                        \n",
    "       # print(\"this is the nNode: \",  neighborNode)\n",
    "        \n",
    "        \n",
    "       \n",
    "    \n",
    "#print(\"Please create the grid by typing: grid = createGrid() with two parameters that will determine the size of the grid\")\n",
    "#print(\"For example: grid = createGrid(20,20) will create a 20 X 20 grid space\")\n",
    "#print(\"After creating the grid type: astarPath(grid, start, end)\")\n",
    "#print(\" start and end are x,y coordinates of the start and end points of the path\")\n",
    "#print(\"For example: astarPath(grid, (0,0), (8,2)), please ensure the points are contained within the grid space\")\n",
    "grid = createGrid(20,20)    \n",
    "#btn.on_click(astarPath(grid, (0,0), (8,2)))   \n",
    "#print (\"Astar took\", time.time() - start_time, \"to run\")\n",
    "\n",
    "print('Create 2 Dimension array to represent search grid')\n",
    "lable1 = widgets.Label(\"Rows\")\n",
    "display(lable1)\n",
    "text1=widgets.Text()\n",
    "display(text1)\n",
    "lable2 = widgets.Label(\"Columns\")\n",
    "display(lable2)\n",
    "text2=widgets.Text()\n",
    "display(text2)\n",
    "gridBtn=widgets.Button(description=\"Create Grid\")\n",
    "\n",
    "display(gridBtn)\n",
    "gridBtn.on_click(onclickGrid)\n",
    "button = widgets.Button(description=\"Run ASTAR\")\n",
    "display(button)\n",
    "button.on_click(onclick)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}