My first thought is to simulate each step, simply, but suppose Part 2 asks me to run it 1000 times? I'll code it efficiently.

I can come up with an efficient implementation. I will have 4 representations of the board, one for each direction of travel. At each cell in the board I will store the number of spaces I can move before hitting a wall or boundary. If the move crosses the boundary, the value there will indicate how far to move back to the other side to finish the move.

```NB. convert a horizontal line to the correct format for moves toward the right.  Board starts with
NB. _1=wall, 0=out of bounds, 1=empty in bounds
fmtline =: {{ ((y=0) * +/ y~:0) + ([ _1:^:(_1=[) +)/\. y }}"1
fmtline 0 0 1 _1 1 1 _1 0 0
5 5 0 _1 1 0 _1 5 5
```

The left part of fmtline counts the number of active cells on the line (5 here) and adds that to the value in the out-of-bounds cells. The only one of these cells that matters is the one after the last in-bounds cell. The right part does a reverse running sum, resetting to _1 when a wall is encountered.

```   fmtboards =: (fmtline , fmtline&.:|: , fmtline&.:(|."1) ,: fmtline&.:(|:@:|.))
lines =:  0 ,"(1) 0 ,~"(1) 0 , 0 ,~ <: '# .' i. ] onaoclines
boards =. fmtboards lines
\$boards
4 14 18
```

I read the lines, surround the area with an out-of-bounds fringe, and translate from characters to the numeric form I have settled on. Then I create the boards to handle moves in all directions. Next I read my move instructions.

```     ]lendir =: ((".@}: , 1 _1 0 {~ 'RLS' i. {:);.2~  e.&'RLS') 'S' ,~ wd 'clippaste'
10  1
5 _1
5  1
10 _1
4  1
5 _1
5  0
```

This is a hook, where e.&'RL' marks the end of the sections and (".@}: , _1 2 p. 'RL' i. {:) is applied to each section. 'RL' i. {: converts the last character to 0 or 1 and 1 _1 {~ translates them to 1 and _1. Since the last move doesn't contain a turn direction, I add one, indicating no turn.

With the boards set up, following instructions is easy. I start a script.

```dirmove =: _2 ]\ 0 1  1 0  0 _1  _1 0  NB. moves in each direction (0=E, 1=S, 2=W, 3=N)
runlendir =: {{   NB. y is list of instructions, boards and lines are set up
dir =. 0  NB. start looking E
pos =. 1 , 01 i.&1@:= 1 { lines  NB. start on top line, at first open cell
for_ld. y do.  NB. for each len/dist pair
'l d' =. ld  NB. separate len and dir
mv =. dir { dirmove  NB. y,x of a move of 1 unit
while. l do.   NB. till we have finished the move
mvdist =. l <. (<dir,pos) { boards  NB. get amount we can move from this square
pos =. pos + mvdist * mv  NB. move the limit
if. (<pos) { lines do. break. end.  NB. if we are still in the board, stop
resetdist =. (<dir,pos) { boards  NB. oob - board gives reset distance
pos =. pos - resetdist * mv  NB. back up to other side
if. 0 > (<pos) { lines do. pos =. pos + (resetdist-1) * mv break. end.  NB. if line starts with wall, stay at end
l =. l - mvdist  NB. pick up at start and finish move
end.
dir =. dir + d  NB. move finished, turn
end.

}}
```

I win no prizes for guessing about Part 2. I will have to rewrite the code completely, step by step.

This isn't a programming problem, it's a topology problem! I fill a sheet of paper with sketches of cubes, with numbered faces and arrows for face orientation. After a while I have what I need: for each face and direction, the face entered and the direction, 48 numbers in all.

I also need to find the coordinate on the entered face. I don't want 48 more error-prone expressions, so I will calculate the coordinate based on the directions.

Since I must refer to the unfolded input board to find blockages, I will keep coordinates as coordinates in that board.

```dirmove =: _2 ]\ 0 1  1 0  0 _1  _1 0  NB. moves in each direction (0=E, 1=S, 2=W, 3=N)
M =: 4
fdtab =: _2 ]\ 5 2  1 1  2 1  3 1  NB. for each (face,dir), the new face,dir when a boundary is crossed
fdtab =: fdtab ,: _2 ]\ 5 1  4 1  2 2  0 3
fdtab =: fdtab , _2 ]\ 1 0  4 0  3 2  0 0
fdtab =: fdtab , _2 ]\ 2 0  4 3  5 3  0 1
fdtab =: fdtab , _2 ]\ 5 0  3 3  2 3  1 3
fdtab =: fdtab , _2 ]\ 0 2  3 0  4 2  1 2
facebase =: M * _2 ]\ 0 2  1 2   1 1  1 0  2 2  2 3  NB. top-left cell of each face in lines

move =: {{  NB. y is face,dir,ypos,xpos  result is same format after move
'face dir posy posx' =. y
pos =. (dir { dirmove) + oldpos =. posy,posx  NB. advance to new position
if. -. pos -:&(<.@(%&M)) oldpos do.  NB. crossing face boundary?
NB. face boundary crossed - update everything
'face dir' =. (<face,olddir =. dir) { fdtab  NB. update face & direction in face
NB. first, establish the coordinate in the direction of motion in the new face.
NB. if that coordinate is increasing, start at 0; decreasing, at M-1
pos =. (_1=dir { dirmove) * (M-1)
NB. establish the other coordinate, also within the new face
staticdir =. M | +/ oldpos * 0=olddir{dirmove  NB. the static coordinate in the old face
if. olddir =&(1&(17 b.)) dir do. compstat =. dir~:olddir
NB. same direction or 180 degrees diff: complement coord if dir change
NB. otherwise the move is +-90 degrees.  We start in a cell in normal board
NB. orientation and move in the direction olddir.  In one of the 90-degree-rotated
NB. orientations, the static coordinate in the olddir increases with increasing
NB. static coordinate in the newdir; for the orther rotation the directions oppose.
NB. compstat is 1 when the directions oppose.
else. compstat =. olddir { dir = 1 0 3 2
end.
pos =. (face{facebase) + pos + (0 = dir{dirmove) * ((M-1)&-)^:compstat staticdir  NB. add the static coord, compld as needed
end.
face,dir,pos  NB. return new stats
}}

runlendir =: {{   NB. y is list of instructions, boards and lines are set up
dir =. 0  NB. start looking E
pos =. 0 , 01 i.&1@:= 0 { lines  NB. start on top line, at first open cell
face =. 0  NB. start in face 0 (good enough)
for_ld. y do.  NB. for each len/turn pair
'l turn' =. ld  NB. separate len and turn
for. i. l do.   NB. till we have finished the move
'nface ndir nposy nposx' =. move face,dir,pos
if. _1 = (<nposy,nposx) { lines do. break. end.  NB. stop before wall
if. 0 = (<nposy,nposx) { lines do. 'out of bounds' 13!:8 ] 1 end.  NB. break if ob
face =. nface [ dir =. ndir [ pos =. nposy,nposx  NB. update pos,dir
end.
dir =. 4 | dir + turn  NB. move finished, turn
end.
0 250 4 #. (>:pos),dir
}}
```

=&(1&(17 b.)) tests for equality in the lowest bit, because (17 b.) is bitwise AND. I could have used =&(2&|).

I should test the move code a bit. I spot-test a few cases and fix the bugs. Eventually I want to test them all.

```    ]  pp =. (i. 6) ,"0/  i. 4
0 0
0 1
0 2
0 3

1 0
...
]ppp =. ([ , 2 2 + facebase {~ {.@[)"1 pp
0 0  2 10
0 1  2 10
0 2  2 10
0 3  2 10

1 0  6 10
...
(] -: move^:(4*M))"1 ppp
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
```

All good. Now to run on the example data. After I fix the result to match the problem's 1-origin indexing, I am pleased to see

```   runlendir mlendir
5031
```