using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;

enum Direction
{
   none = 0,
   north,
   south,
   east,
   west,
}

struct Point
{
   public int x;
   public int y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public void Move(Direction direction)
   {
      switch (direction)
      {
         case Direction.north:
            y--;
            break;
         case Direction.south:
            y++;
            break;
         case Direction.east:
            x++;
            break;
         case Direction.west:
            x--;
            break;
      }
   }
}

class Person
{
   private Point point;
   public Point Point { get { return point; } private set { point = value; } }

   public Person(int initX = 0, int initY = 0)
   {
      point = new Point(initX, initY);
   }

   public void Move(Direction direction)
   {
      point.Move(direction);
   }
}

class MoveTile
{
   public Direction Direction { get; private set; }

   public MoveTile(Direction direction)
   {
      Direction = direction;
   }

   public void MovePerson(Person person)
   {
      person.Move(Direction);
   }
}

class TileRoom
{
   public TileRoom(int width, int height)
   {
      map = new MoveTile[width, height];
   }

   private MoveTile[,] map;
   private Point loadPoint = new Point(0, 0);

   public void Load(char tileKind)
   {
      MoveTile tile = null;
      switch (tileKind)
      {
         case '>':
            tile = new MoveTile(Direction.east);
            break;
         case '<':
            tile = new MoveTile(Direction.west);
            break;
         case '^':
            tile = new MoveTile(Direction.north);
            break;
         case 'v':
            tile = new MoveTile(Direction.south);
            break;
         case '.':
            tile = new MoveTile(Direction.none);
            break;
      }
      map[loadPoint.x, loadPoint.y] = tile;
      loadPoint.Move(Direction.east);

      if (loadPoint.x >= map.GetLength(0))
      {
         loadPoint.x = 0;
         loadPoint.Move(Direction.south);
      }
   }
   public void Load(char[] tileKinds)
   {
      foreach (char tileKind in tileKinds)
      {
         Load(tileKind);
      }
   }
   public void Load(string tiles)
   {
      Load(tiles.ToCharArray());
   }

   public struct Result
   {
      public bool isFinished;
      public Point end;
   }

   public Result SetPerson(Person person)
   {
      var root = new List<Point>();

      while (!root.Contains(person.Point))
      {
         var tile = map[person.Point.x, person.Point.y];
         if (tile.Direction == Direction.none)
         {
            return new Result(){ isFinished = true, end = person.Point };
         }

         root.Add(person.Point);
         tile.MovePerson(person);
      }

      return new Result(){ isFinished = false };
   }
}

class MainClass
{
   static void Main(string[] args)
   {
      var stringbuilder = new StringBuilder();

      while (true)
      {
         string[] datas = Console.ReadLine().Split(' ');
         int H = int.Parse(datas[0]);
         int W = int.Parse(datas[1]);
         if (H == 0 && W == 0) { break; }

         var room = new TileRoom(W, H);
         for (int row = 0; row < H; row++) {
            string line = Console.ReadLine();
            room.Load(line);
         }

         var person  = new Person();
         var result = room.SetPerson(person);

         if (result.isFinished) {
            stringbuilder.Append(result.end.x.ToString());
            stringbuilder.Append(" ");
            stringbuilder.Append(result.end.y.ToString());

            stringbuilder.AppendLine();
         } else {
            stringbuilder.AppendLine("LOOP");
         }
      }

      Console.Write(stringbuilder.ToString());
   }
}


Measured memory_bytes: 9976