function W = solver(B)
answer = [];
answer = zeros(0,4);


dimentions = size(B);
rows = dimentions(1);
cols = dimentions(2);

wiresHor = zeros(rows,cols-1);
wiresVer = zeros(rows-1,cols);

uni = unique(B);
uni = uni(find(uni ~= 0));



uniCount = length(uni);
[emptyR emptyC] = find(B==0);

value = [];
amount = [];
weight = [];

for i=1:uniCount
    next = uni(i);
    value = [value; next];
    [placedr placedc] = find(B==next);
    timesFound = length(placedr);
    amount = [amount; timesFound];
    if(timesFound == 1)
        weight = [weight; 0];
    else
        weight = [weight; next*timesFound];
    end;
end;


% Start value vector. (All the unique values in the matrix)
%value
% Number of occurances for each unique value in the matrix
%amount
% The total weight of each value. That is the number of occurances
% multiplied by the value itself. (Note, if the value only occur once it
% has a zero value)
%weight
origWeight = weight;


grid = zeros(rows,cols);
connected = zeros(rows,cols);
 
nextIdx = find(weight == max(weight));
if length(nextIdx) > 1
    nextIdx = nextIdx(1);
end;
nextValue = value(nextIdx);
weight(nextIdx) = -1;


checkedOnceR = [];
checkedOnceC = [];

[placedr placedc] = find(B==nextValue);

linkedR = [];
linkedC = [];

currR = placedr(1);
currC = placedc(1);

unConnectedR = placedr;
unConnectedC = placedc;

% Remove the first value from the chain. 
placedr = placedr(2:length(placedr));
placedc = placedc(2:length(placedc));

% [lengths] = findClosest(B,currR,currC,placedr,placedc);
% closest = min(lengths);
% closestIndex = find(lengths == closest,1);
% gotoR = placedr(closestIndex);
% gotoC = placedc(closestIndex);


%Find first move (Connect two nodes of the same type)
[unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,placedr,placedc,1);
% if validFound == 0
%     unConnectedR = [unConnectedR; currR];
%     unConnectedC = [unConnectedC; currC];
%     currR = placedr(1);
%     currC = placedc(1);
%     placedr = placedr(2:length(placedr));
%     placedc = placedc(2:length(placedc));
%     [unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,placedr,placedc,1);
% end;
%  if validFound == 0
%      fprintf('assd;fasj;asldjasdlfjhasljhfasldjhfasldjhfasljdhfalshffdkjasdf \n');
%  end;

while validFound == 1 && length(unConnectedR) > 0
    [unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,linkedR,linkedC,0);
end;
% if validFound == 1 && length(unConnectedR) > 0
%     [unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,linkedR,linkedC,0);
% end;
% if validFound == 1 && length(unConnectedR) > 0
%     [unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,linkedR,linkedC,0);
% end;
% if validFound == 1 && length(unConnectedR) > 0
%     [unConnectedR,unConnectedC,answer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,linkedR,linkedC,0);
% end;
% 


W = answer;


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [unConnectedR,unConnectedC,myanswer,linkedR,linkedC,validFound] = doNextMove(B,unConnectedR,unConnectedC,answer,linkedR,linkedC,first)
myanswer = [];
validFound = 0;

currR = unConnectedR(1);
currC = unConnectedC(1);

% Remove the first value from the chain. 
unConnectedR = unConnectedR(2:length(unConnectedR));
unConnectedC = unConnectedC(2:length(unConnectedC));

% [lengths] = findClosest(B,currR,currC,linkedR,linkedC);
% 
% closest = min(lengths);
% closestIndex = find(lengths == closest,1);
% gotoR = linkedR(closestIndex);
% gotoC = linkedC(closestIndex);

possibleMoves = ones(28,1)*100000;

useLen1 = zeros(28,1);
useLen2 = zeros(28,1);
useLen3 = zeros(28,1);
useLen4 = zeros(28,1);

useGotoR = zeros(28,1);
useGotoC = zeros(28,1);

len1 = zeros(28,1); % First horizontal distance
len2 = zeros(28,1); % First vertical distance
len3 = zeros(28,1); % Second horizontal distance
len4 = zeros(28,1); % Second vertical distance

for aaa=1:length(linkedR)
    len1(1) = checkRight(B,currR,currC,linkedR(aaa),linkedC(aaa),0);
    len1(2) = checkLeft(B,currR,currC,linkedR(aaa),linkedC(aaa),0);
    len2(3) = checkUp(B,currR,currC,linkedR(aaa),linkedC(aaa),0);
    len2(4) = checkDown(B,currR,currC,linkedR(aaa),linkedC(aaa),0);

    [len1(5),len2(5),len3(5),len4(5)] = bounceTop(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(6),len2(6),len3(6),len4(6)] = bounceTop2(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(7),len2(7),len3(7),len4(7)] = bounceRight(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(8),len2(8),len3(8),len4(8)] = bounceRight2(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(9),len2(9),len3(9),len4(9)] = bounceBottom(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(10),len2(10),len3(10),len4(10)] = bounceBottom(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(11),len2(11),len3(11),len4(11)] = bounceLeft(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(12),len2(12),len3(12),len4(12)] = bounceLeft2(B,currR,currC,linkedR(aaa),linkedC(aaa));
    
    %[len1(13),len2(13),len3(13),len4(13)] = bounceRightUpRight(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(14),len2(14),len3(14),len4(14)] = bounceLeftDownLeft(B,currR,currC,linkedR(aaa),linkedC(aaa));
    
    [len1(21),len2(21)] = checkUpRight(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(22),len2(22)] = checkLeftDown(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(23),len2(23)] = checkDownRight(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(24),len2(24)] = checkLeftUp(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(25),len2(25)] = checkRightUp(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(26),len2(26)] = checkDownLeft(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(27),len2(27)] = checkRightDown(B,currR,currC,linkedR(aaa),linkedC(aaa));
    [len1(28),len2(28)] = checkUpLeft(B,currR,currC,linkedR(aaa),linkedC(aaa));

    for i=1:28    
        if len1(i) >= 0 && len2(i) >= 0 && len3(i) >= 0 && len4(i) >= 0 
            sum = len1(i)+len2(i)+len3(i)+len4(i);
            if (sum < possibleMoves(i)) && (sum > 0)
                useLen1(i) = len1(i);
                useLen2(i) = len2(i);       
                useLen3(i) = len3(i);
                useLen4(i) = len4(i);
                useGotoR(i) = linkedR(aaa);
                useGotoC(i) = linkedC(aaa);                
                possibleMoves(i) = sum;
            end;
        end;
        if possibleMoves(i) == 0
            possibleMoves(i) = 100000;
        end;
    end;
end

if min(possibleMoves) ~= 100000
    
    if first==1
        linkedR = [];
        linkedC = [];
        linkedR = [linkedR; currR];
        linkedC = [linkedC; currC];
    end;

    validFound = 1;
%    possibleMoves
    doMove = find(possibleMoves==min(possibleMoves),1);

    newmoves  = [];
    newmoves2 = [];
    newmoves3 = [];    
    switch doMove
        case 1  
            [newmoves,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen1(1),currR,currC);
        case 2  
            [newmoves,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen1(2),currR,currC);
        case 3  
            [newmoves,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen2(3),currR,currC);
        case 4  
            [newmoves,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen2(4),currR,currC);
        case 5
            [newmoves,linkedR,linkedC]  = genMoveU(linkedR,linkedC,B,useLen1(5),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen3(5),useGotoR(5),useGotoC(5));
            [newmoves3,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen2(5),currR-useLen1(5),currC);
        case 6
            [newmoves,linkedR,linkedC]  = genMoveU(linkedR,linkedC,B,useLen1(6),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen3(6),useGotoR(6),useGotoC(6));
            [newmoves3,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen2(6),currR-useLen1(6),currC);
        case 7
            [newmoves,linkedR,linkedC]  = genMoveR(linkedR,linkedC,B,useLen2(7),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen4(7),useGotoR(7),useGotoC(7));
            [newmoves3,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen1(7),currR,currC+useLen2(7));
        case 8
            [newmoves,linkedR,linkedC]  = genMoveR(linkedR,linkedC,B,useLen2(8),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen4(8),useGotoR(8),useGotoC(8));
            [newmoves3,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen1(8),currR,currC+useLen2(8));
        case 9
            [newmoves,linkedR,linkedC]  = genMoveD(linkedR,linkedC,B,useLen1(9),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen3(9),useGotoR(9),useGotoC(9));
            [newmoves3,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen2(9),currR+useLen1(9),currC);
        case 10
            [newmoves,linkedR,linkedC]  = genMoveD(linkedR,linkedC,B,useLen1(10),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen3(10),useGotoR(10),useGotoC(10));
            [newmoves3,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen2(10),currR+useLen1(10),currC);
        case 11
            [newmoves,linkedR,linkedC]  = genMoveL(linkedR,linkedC,B,useLen2(11),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen4(11),useGotoR(11),useGotoC(11));
            [newmoves3,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen1(11),currR,currC-useLen2(11));
        case 12
            [newmoves,linkedR,linkedC]  = genMoveL(linkedR,linkedC,B,useLen2(12),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen4(12),useGotoR(12),useGotoC(12));
            [newmoves3,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen1(12),currR,currC-useLen2(12));
        case 14
            [newmoves,linkedR,linkedC]  = genMoveL(linkedR,linkedC,B,useLen2(14),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen4(14),useGotoR(14),useGotoC(14));
            [newmoves3,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen1(14),currR,currC-useLen2(14));
        case 21
            [newmoves,linkedR,linkedC]  = genMoveU(linkedR,linkedC,B,useLen1(21),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen2(21),useGotoR(21),currC);
        case 22
            [newmoves,linkedR,linkedC]  = genMoveL(linkedR,linkedC,B,useLen2(22),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen1(22),currR,useGotoC(22));
        case 23
            [newmoves,linkedR,linkedC]  = genMoveD(linkedR,linkedC,B,useLen1(23),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,useLen2(23),useGotoR(23),currC);
        case 24
            [newmoves,linkedR,linkedC]  = genMoveL(linkedR,linkedC,B,useLen2(24),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen1(24),currR,useGotoC(24));
        case 25
            [newmoves,linkedR,linkedC]  = genMoveR(linkedR,linkedC,B,useLen2(25),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveU(linkedR,linkedC,B,useLen1(25),currR,useGotoC(25));
        case 26
            [newmoves,linkedR,linkedC]  = genMoveD(linkedR,linkedC,B,useLen1(26),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen2(26),useGotoR(26),currC);
        case 27
            [newmoves,linkedR,linkedC]  = genMoveR(linkedR,linkedC,B,useLen2(27),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveD(linkedR,linkedC,B,useLen1(27),currR,useGotoC(27));
        case 28
            [newmoves,linkedR,linkedC]  = genMoveU(linkedR,linkedC,B,useLen1(28),currR,currC);
            [newmoves2,linkedR,linkedC] = genMoveL(linkedR,linkedC,B,useLen2(28),useGotoR(28),currC);
        otherwise        % No valid move found
    end;

    if first==1
        idx = find(unConnectedR==useGotoR(doMove));
        p1 = unConnectedR(1:idx-1);
        p2 = unConnectedR(idx+1:length(unConnectedR));
        unConnectedR = [p1;p2];

        p1 = unConnectedC(1:idx-1);
        p2 = unConnectedC(idx+1:length(unConnectedC));
        unConnectedC = [p1;p2];    
    end;
    
    myanswer = [answer; newmoves; newmoves2; newmoves3];

else
    myanswer = answer;
    
    noMoveFound = 1;
end;


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [lengths] = findClosest(B,currR,currC,placedr,placedc)
possible = length(placedr);
lengths = [];
for i=1:possible
    len = 0;
    len = abs(currR - placedr(i)) + abs(currC - placedc(i));
    lengths = [lengths; len];
end;


function [newmoves,linkedR,linkedC] = genMoveR(linkedR,linkedC,B,dist,currR,currC)
%dist
newmoves = [];
col = currC;
linkedR = [linkedR; currR];
linkedC = [linkedC; currC];
for i=1:dist
    newmoves = [newmoves; currR col currR col+1];
    linkedR = [linkedR; currR];
    linkedC = [linkedC; col+1];
    lastR = currR;
    lastC = col+1;
    col = col + 1;
end;

function [newmoves,linkedR,linkedC,lastR,lastC] = genMoveL(linkedR,linkedC,B,dist,currR,currC)
newmoves = [];
col = currC;
linkedR = [linkedR; currR];
linkedC = [linkedC; currC];
for i=1:dist
    newmoves = [newmoves; currR col currR col-1];
    linkedR = [linkedR; currR];
    linkedC = [linkedC; col-1];
    lastR = currR;
    lastC = col-1;
    col = col - 1;
end;

function [newmoves,linkedR,linkedC,lastR,lastC] = genMoveD(linkedR,linkedC,B,dist,currR,currC)
newmoves = [];
row = currR;
linkedR = [linkedR; currR];
linkedC = [linkedC; currC];
for i=1:dist
    newmoves = [newmoves; row currC row+1 currC];
    linkedR = [linkedR; row+1];
    linkedC = [linkedC; currC];
    lastR = row+1;
    lastC = currC;
    row = row + 1;
end;

function [newmoves,linkedR,linkedC,lastR,lastC] = genMoveU(linkedR,linkedC,B,dist,currR,currC)
newmoves = [];
row = currR;
linkedR = [linkedR; currR];
linkedC = [linkedC; currC];
for i=1:dist
    newmoves = [newmoves; row currC row-1 currC];
    linkedR = [linkedR; row-1];
    linkedC = [linkedC; currC];
    lastR = row-1;
    lastC = currC;
    row = row - 1;
end;


% MOVE 1
function len = checkLeft(B,currR,currC,toR,toC,corner)
clear = 1;
len = -1;
if currR == toR
    if corner == 0
        go = toC+1;
    else
        go = toC;
    end;
    for i=go:currC-1
        if B(currR,i) ~= 0
            clear = 0;
        end;
    end;
    if clear == 1
        len = currC-toC;
    end;
end;


% MOVE 2
function len = checkRight(B,currR,currC,toR,toC,corner)
clear = 1;
len = -1;
if currR == toR
    if corner == 0
        go = toC-1;
    else
        go = toC;
    end;    
    for i=currC+1:go
        if B(currR,i) ~= 0
            clear = 0;
        end;
    end;
    if clear == 1
        len = toC-currC;
    end;
end;

% MOVE 3
function len = checkUp(B,currR,currC,toR,toC,corner)
clear = 1;
len = -1;
if currC == toC
    if corner == 0
        go = toR+1;
    else
        go = toR;
    end;    
    for i=go:currR-1
        if B(i,currC) ~= 0
            clear = 0;
        end;
    end;
    if clear == 1
        len = currR-toR;
    end;
end;
    

% MOVE 4
function len = checkDown(B,currR,currC,toR,toC,corner)
clear = 1;
len = -1;
if currC == toC
    if corner == 0
        go = toR-1;
    else
        go = toR;
    end;    
    for i=currR+1:go
        if B(i,currC) ~= 0
            clear = 0;
        end;
    end;
    if clear == 1
        len = toR-currR;
    end;
end;

% MOVE 5
function [len1,len2,len3,len4] = bounceTop(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currR > 1
    for i=1:currR-1
        testLen2 = checkRight(B,i,currC,i,toC,0);
        testLen1 = -1;  testLen3 = -1;
        if testLen2 > 1
            testLen1 = checkUp(B,currR,currC,i,currC,1);
            testLen3 = checkUp(B,toR,toC,i,toC,1);
        end;
        if testLen1 > 0 && testLen3 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = testLen3;
            len4 = 0;
        end;
    end;
end;

% MOVE 6
function [len1,len2,len3,len4] = bounceTop2(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currR > 1
    for i=1:currR-1
        testLen2 = checkLeft(B,i,currC,i,toC,0);
        testLen1 = -1;  testLen3 = -1;
        if testLen2 > 1
            testLen1 = checkUp(B,currR,currC,i,currC,1);
            testLen3 = checkUp(B,toR,toC,i,toC,1);
        end;
        if testLen1 > 0 && testLen3 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = testLen3;
            len4 = 0;
        end;
    end;
end;

% MOVE 7
function [len1,len2,len3,len4] = bounceRight(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currC < size(B,2)
    for i=currC+1:size(B,2)
        testLen1 = checkUp(B,currR,i,toR,i,0);
        testLen2 = -1; testLen4 = -1;
        if testLen1 > 1
            testLen2 = checkRight(B,currR,currC,currR,i,1);
            testLen4 = checkRight(B,toR,toC,toR,i,1);
        end;
        if testLen2 > 0 && testLen4 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = 0;
            len4 = testLen4;
        end;
    end;
end;

% MOVE 8
function [len1,len2,len3,len4] = bounceRight2(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currC < size(B,2)
    for i=currC+1:size(B,2)
        testLen1 = checkDown(B,currR,i,toR,i,0);
        testLen2 = -1; testLen4 = -1;
        if testLen1 > 1
            testLen2 = checkRight(B,currR,currC,currR,i,1);
            testLen4 = checkRight(B,toR,toC,toR,i,1);
        end;
        if testLen2 > 0 && testLen4 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = 0;
            len4 = testLen4;
        end;
    end;
end;

% MOVE 9
function [len1,len2,len3,len4] = bounceBottom(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currR < size(B,1)
    for i=currR+1:size(B,1)
        testLen2 = checkRight(B,i,currC,i,toC,0);
        testLen1 = -1;  testLen3 = -1;
        if testLen2 > 1
            testLen1 = checkDown(B,currR,currC,i,currC,1);
            testLen3 = checkDown(B,toR,toC,i,toC,1);
        end;
        if testLen1 > 0 && testLen3 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = testLen3;
            len4 = 0;
        end;
    end;
end;

% MOVE 10
function [len1,len2,len3,len4] = bounceBottom2(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currR < size(B,1)
    for i=currR+1:size(B,1)
        testLen2 = checkLeft(B,i,currC,i,toC,0);
        testLen1 = -1;  testLen3 = -1;
        if testLen2 > 1
            testLen1 = checkDown(B,currR,currC,i,currC,1);
            testLen3 = checkDown(B,toR,toC,i,toC,1);
        end;
        if testLen1 > 0 && testLen3 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = testLen3;
            len4 = 0;
        end;
    end;
end;

% MOVE 11
function [len1,len2,len3,len4] = bounceLeft(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currC > 1
    for i=1:currC-1
        testLen1 = checkUp(B,currR,i,toR,i,0);
        testLen2 = -1; testLen4 = -1;
        if testLen1 > 1
            testLen2 = checkLeft(B,currR,currC,currR,i,1);
            testLen4 = checkLeft(B,toR,toC,toR,i,1);
        end;
        if testLen2 > 0 && testLen4 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = 0;
            len4 = testLen4;
        end;
    end;
end;

% MOVE 12
function [len1,len2,len3,len4] = bounceLeft2(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
if currC > 1
    for i=1:currC-1
        testLen1 = checkDown(B,currR,i,toR,i,0);
        testLen2 = -1; testLen4 = -1;
        if testLen1 > 1
            testLen2 = checkLeft(B,currR,currC,currR,i,1);
            testLen4 = checkLeft(B,toR,toC,toR,i,1);
        end;
        if testLen2 > 0 && testLen4 > 0
            len1 = testLen1;
            len2 = testLen2;
            len3 = 0;
            len4 = testLen4;
        end;
    end;
end;


% MOVE 14
function [len1,len2,len3,len4] = bounceLeftDownLeft(B,currR,currC,toR,toC)
len1 = -1; len2 = -1; len3 = -1; len4 = -1;
testLen2 = -1; testLen2 = -1; testLen3 = -1; testLen4 = -1;
for i=toC+1:currC-1
    testLen1 = checkDown(B,currR,i,toR,i,0);
    testLen2 = -1; testLen4 = -1;
    if testLen1 > 1
        testLen2 = checkLeft(B,currR,currC,currR,i,1);
        testLen4 = checkRight(B,toR,toC,toR,i,1);
    end;
    if testLen2 > 0 && testLen4 > 0
        len1 = testLen1;
        len2 = testLen2;
        len3 = 0;
        len4 = testLen4;
    end;
end;


% MOVE 21
function [len1,len2] = checkUpRight(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkUp(B,currR,currC,toR,currC,1);
    len2 = checkRight(B,toR,currC,toR,toC,0);
end;

% MOVE 22
function [len1,len2] = checkLeftDown(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkDown(B,currR,toC,toR,toC,0);
    len2 = checkLeft(B,currR,currC,currR,toC,1);
end;

% MOVE 23
function [len1,len2] = checkDownRight(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkDown(B,currR,currC,toR,currC,1);
    len2 = checkRight(B,toR,currC,toR,toC,0);
end;

% MOVE 24
function [len1,len2] = checkLeftUp(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkUp(B,currR,toC,toR,toC,0);
    len2 = checkLeft(B,currR,currC,currR,toC,1);
end;

% MOVE 25
function [len1,len2] = checkRightUp(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkUp(B,currR,toC,toR,toC,0);
    len2 = checkRight(B,currR,currC,currR,toC,1);
end;

% MOVE 26
function [len1,len2] = checkDownLeft(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkDown(B,currR,currC,toR,currC,1);
    len2 = checkLeft(B,toR,currC,toR,toC,0);
end;

% MOVE 27
function [len1,len2] = checkRightDown(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkDown(B,currR,toC,toR,toC,0);
    len2 = checkRight(B,currR,currC,currR,toC,1);
end;

% MOVE 28
function [len1,len2] = checkUpLeft(B,currR,currC,toR,toC)
len1 = -1; 
len2 = -1;
if (currR ~= toR) && (currC ~= toC)
    len1 = checkUp(B,currR,currC,toR,currC,1);
    len2 = checkLeft(B,toR,currC,toR,toC,0);
end;