#[Lost](https://github.com/Wheatwizard/Lost), <s>57</s> <s>23</s> 22 bytes

 <^/*(
 )/@+
 ">>v
 ^?%<<

My first Lost answer. Thought I'd start with an easy one.

Byte-count more than halved (-25 bytes) thanks to *@JoKing*.

[Try it online](https://tio.run/##y8kvLvn/3yZOX0uDS0FT30GbS8nOrowrzl7Vxub/fwA) or [verify that it's deterministic](https://tio.run/##y8kvLvn/3yZOX0uDS0FT30GbS8nOrowrzl7Vxub///@6YQA).

**General explanation about Lost:**

Let me start with an explanation of Lost itself. Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that ***both the start position AND starting direction it travels in is completely random***. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.

A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up, down, left, or right.

In Lost you therefore want to lead everything to a starting position so it follows the designed path you want it to. In addition, you'll usually have to clean up the stack when it starts somewhere in the middle.

**Program explanation:**

The 22-bytes program is similar as the previous 23-bytes program below, but with a smarter path to save that byte:

 v<<<<<>>>>>
 >%?"^ <"*+@

Let me start with an explanation of the 23-bytes program:

The `"^ <"*+` will push the character-codepoints for the three characters in the string, being `94 32 60` respectively. The `*` multiplies the top two, and `+` adds the top two of the stack, so it becomes `94+(32*60)`, which results in `2014`.

The `@` will terminate the program, but only if the safety is 'off'. When the program starts the safety is always 'on', otherwise the program starting at the exit character immediately terminates without doing anything. 
The `%` will turn the safety 'off'. So as soon as the `%` is encountered and the safety is 'off', the program can be terminated with an `@`.

The `?` is to clean up the stack if it started somewhere in the middle.

And finally the `v<<<<<>>>>>`, `>` and use of `^ <` in the string are to lead the program path towards the correct starting position for it to correctly print `2014`. Note that the top line could have been `v<<<<<<<<<<`, but that the reversed part `>>>>>` will wrap-around to the other side, making the path shorter and therefore the performance slightly better. The byte-count remains the same anyway, so why not.

------

Now for the 22-bytes solution, and how it actually is the same as the 23-bytes solution, but with a different path.

The arrows are still used to lead the path into the given direction. The `/` are used as a mirror. So if we go from right to left and encounter the `/`, it will continue downwards; if we go from the top to the bottom and encounter the `/`, it will continue towards the left; etc.

The `(` will pop the top value on the stack and push to to the scope, and the `)` will do the reversed: it pops from the scope, and pushes it back to the stack.

So regardless of where we start and in which direction we travel, the path leads towards the first `<` of the bottom row. From there, the program flow travels in this order:

 %?^ Direction changed upwards
 " <^" < Direction changed towards the left
 (*/ Direction changed downwards
 / Direction changed towards the left
 ) +@

So it will:

- Turn the safety 'off' with `%`;
- Clean the stack with `?`;
- Push the character-codepoints for `" <^"`, which are `32 60 94` respectively;
- Pop the `94` and store it in the scope with `(`;
- Multiply the `32 60` with `*`, resulting in `1920`;
- Push the `94` from the scope back onto the stack with `)`;
- Add the `1920 94` together with `+`, resulting in `2014`;
- And then terminates the program with `@`.