iu have the code and it prints but not as required please help me to get the same output from my code here is the code import sys

import time

from collections import deque

class SlidingBrickPuzzle:

def $\_\_$init$\_\_($self$,$ filename$)$:

self.initial$\_$state $=$ self.load$\_$game$\_$state$($filename$)$

def load$\_$game$\_$state$($self$,$ filename$)$:

with open$($filename$,\text{'}$r$\text{'})$ as file:

lines $=$ file.read$().$splitlines$()$

if not lines:

print$("$Empty input file. Please provide valid input."$)$

sys$.$exit$(1)$

try:

dimensions $=[$int$($dim$)$ for dim in lines$[0].$split$(\text{'},\text{'})$ if dim.strip$()]$

if len$($dimensions$)!=2$:

raise ValueError$("$Invalid dimensions format."$)$

except ValueError as e:

print$($f$"$Error parsing dimensions from the first line: $\{$e$\}")$

sys$.$exit$(1)$

state$\_$matrix $=[]$

for line in lines$[1$:$]$:

if line.strip$()$:

row $=[]$

values $=$ line.split$(\text{'},\text{'})$

for value in values:

try:

if value.strip$()$:

row.append$($int$($value$))$

else:

print$($f$"$Warning: Empty value in row: $\{$line$\}")$

except ValueError as e:

print$($f$"$Error parsing value $\text{'}\{$value$\}\text{'}$ in row $\text{'}\{$line$\}\text{'}$: $\{$e$\}")$

sys$.$exit$(1)$

state$\_$matrix.append$($row$)$

return $[$dimensions$,$ state$\_$matrix$]$

def display$\_$state$($self$,$ state$)$:

dimensions, matrix $=$ state

w$,$ h $=$ dimensions

print$()$

for i in range$($h$)$:

row $=",".$join$($map$($str$,$ matrix$[$i$]))$

print$($row$)$

print$()$

def compare$\_$states$($self$,$ state$1,$ state$2)$:

return state$1==$ state$2$

def normalize$\_$state$($self$,$ state$)$:

dimensions, matrix $=$ state

w$,$ h $=$ dimensions

next$\_$idx $=3$

for i in range$($h$)$:

for j in range$($w$)$:

if matrix$[$i$][$j$]==$ next$\_$idx:

next$\_$idx $+=1$

elif matrix$[$i$][$j$]>$ next$\_$idx:

self.swap$\_$idx$($matrix$,$ next$\_$idx, matrix$[$i$][$j$])$

next$\_$idx $+=1$

return $[$dimensions$,$ matrix$]$

def swap$\_$idx$($self$,$ matrix, idx$1,$ idx$2)$:

for i in range$($len$($matrix$))$:

for j in range$($len$($matrix$[$i$]))$:

if matrix$[$i$][$j$]==$ idx$1$:

matrix$[$i$][$j$]=$ idx$2$

elif matrix$[$i$][$j$]==$ idx$2$:

matrix$[$i$][$j$]=$ idx$1$

def available$\_$moves$($self$,$ state$)$:

dimensions, matrix $=$ state

w$,$ h $=$ dimensions

moves $=[]$

for i in range$($h$)$:

for j in range$($w$)$:

if matrix$[$i$][$j$]>=3$:

self.add$\_$possible$\_$moves$($moves$,$ matrix$[$i$][$j$],$ i$,$ j$,$ w$,$ h$)$

return moves

def add$\_$possible$\_$moves$($self$,$ moves, piece, row, col, w$,$ h$)$:

if row $>0$:

moves.append$(($piece$,\text{'}$up$\text{'}))$

if row $<$ h $-1$:

moves.append$(($piece$,$ 'down'$))$

if col $>0$:

moves.append$(($piece$,$ 'left'$))$

if col $<$ w $-1$:

moves.append$(($piece$,$ 'right'$))$

def apply$\_$move$($self$,$ state, move$)$:

dimensions, matrix $=$ state

w$,$ h $=$ dimensions

piece, direction $=$ move

for i in range$($h$)$:

for j in range$($w$)$:

if matrix$[$i$][$j$]==$ piece:

new$\_$i$,$ new$\_$j $=$ self.get$\_$new$\_$position$($i$,$ j$,$ direction$)$

if self.is$\_$valid$\_$move$($matrix$,$ piece, new$\_$i$,$ new$\_$j$,$ w$,$ h$)$:

matrix$[$i$][$j$]=0$

matrix$[$new$\_$i$][$new$\_$j$]=$ piece

return self.normalize$\_$state$([$dimensions$,$ matrix$])$

return state

def get$\_$new$\_$position$($self$,$ i$,$ j$,$ direction$)$:

if direction $==\text{'}$up$\text{'}$:

return i $-1,$ j

elif direction $==$ 'down':

return i $+1,$ j

elif direction $==$ 'left':

return i$,$ j $-1$

elif direction $==$ 'right':

return i$,$ j $+1$

def is$\_$valid$\_$move$($self$,$ matrix, piece, new$\_$i$,$ new$\_$j$,$ w$,$ h$)$:

return $0<=$ new$\_$i $<$ h and $0<=$ new$\_$j $<$ w and matrix$[$new$\_$i$][$new$\_$j$]==0$

def done$($self$,$ state$)$:

dimensions, matrix $=$ state

for row in matrix:

if $-1$ in row:

return False

return True

def random$\_$walk$($self$,$ state, n$)$:

moves $=[]$

for $\_$ in range$($n$)$:

possible$\_$moves $=$ self.available$\_$moves$($state$)$

if not possible$\_$moves:

break

move $=$ possible$\_$moves$[0]$

moves.append$($move$)$

state $=$ self.apply$\_$move$($state$,$ move$)$

self.display$\_$state$($state$)$

if self.done$($state$)$:

break

return moves, state

def bfs$($self$,$ state$)$: