[Question]
  [
Why should you golf in Haskell? [Find out here](https://codegolf.meta.stackexchange.com/a/10668/66833). In that answer, [Zgarb](https://codegolf.meta.stackexchange.com/users/32014/zgarb) defines a task:
> 
> Let's define a function `f` that splits a list at the second occurrence of the first element, e.g. `[0,2,2,3,0,1,0,1] -> ([0,2,2,3],[0,1,0,1])`:
> 
> 
> 
Alright then, lets!
You are to take a non-empty list consisting of digits, and output a **pair** of lists, clearly distinguished, such that the output is the input split before the second occurrence of the first element.
For example, you may output two strings of digits with a non-digit separator. The separator you choose between the elements of each pair and the pairs themselves must be distinct (e.g. space and newline), consistent and not contain digits.
The output must only contain **2** elements however. You may not output empty lists in the output. If you choose to use newlines as a separator between pairs, you may not have a leading newline. You may have trailing newlines no matter what, and you may have trailing whitespace, so long as its sensible.
You may assume:
* The input will be provided in any [convenient method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods), and you may output in any convenient method
* The input will either be a list of digits, or a string
* The input will only contain the integers `0` though to `9`
* The first element of the input will always occur at least twice
* The input will always have 3 or more elements in it
Additionally, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins
## Test cases
```
[1, 1, 9] -> [[1], [1, 9]]
[4, 9, 4] -> [[4, 9], [4]]
[5, 7, 5, 5] -> [[5, 7], [5, 5]]
[8, 8, 0, 7] -> [[8], [8, 0, 7]]
[7, 1, 5, 7, 4, 2] -> [[7, 1, 5], [7, 4, 2]]
[0, 6, 9, 1, 1, 0, 2] -> [[0, 6, 9, 1, 1], [0, 2]]
[2, 9, 3, 2, 4, 2, 5, 9] -> [[2, 9, 3], [2, 4, 2, 5, 9]]
[0, 2, 2, 3, 0, 1, 0, 1] -> [[0, 2, 2, 3], [0, 1, 0, 1]]
[2, 7, 4, 6, 2, 6, 6, 4, 8, 2] -> [[2, 7, 4, 6], [2, 6, 6, 4, 8, 2]]
[8, 2, 2, 7, 5, 4, 7, 0, 8, 0, 7] -> [[8, 2, 2, 7, 5, 4, 7, 0], [8, 0, 7]]
[8, 7, 8, 9, 4, 2, 9, 4, 5, 7, 5, 1, 9] -> [[8, 7], [8, 9, 4, 2, 9, 4, 5, 7, 5, 1, 9]]
[3, 8, 1, 1, 7, 3, 6, 9, 7, 1, 4, 3, 4] -> [[3, 8, 1, 1, 7], [3, 6, 9, 7, 1, 4, 3, 4]]
[4, 7, 0, 5, 6, 5, 0, 1, 7, 8, 7, 8, 4, 1] -> [[4, 7, 0, 5, 6, 5, 0, 1, 7, 8, 7, 8], [4, 1]]
[2, 1, 8, 0, 3, 2, 2, 5, 7, 9, 4, 3, 5, 1, 9, 6, 9] -> [[2, 1, 8, 0, 3], [2, 2, 5, 7, 9, 4, 3, 5, 1, 9, 6, 9]]
[1, 1, 4, 1, 2, 5, 5, 3, 3, 4, 3, 2, 0, 8, 6, 0, 3] -> [[1], [1, 4, 1, 2, 5, 5, 3, 3, 4, 3, 2, 0, 8, 6, 0, 3]]
[4, 3, 5, 2, 2, 0, 6, 4, 8, 6, 6, 6, 7, 3, 4, 8, 7, 6] -> [[4, 3, 5, 2, 2, 0, 6], [4, 8, 6, 6, 6, 7, 3, 4, 8, 7, 6]]
```
  
[Answer]
# [Haskell](https://www.haskell.org/), 26 bytes
```
f(x:y)=([x],0)*>span(/=x)y
```
[Try it online!](https://tio.run/##lZTJTsMwEIbvfYo5cEiQK7I4ziKFOyceIPIhElRULaGiHNKnD/YsDVmgQrKiZub77d8zk76158Pr8TgMu6CvLmEdNL1VUXj/eD61XfBQ9@FleG/3HVQVPD1DEG7wrYaXjw3A6XPffcEd7KCJFbhVWthuoWliqzBUWjvFtIsp0Iz5N0/qOZYpyBW4Z8akD3gSQzO4UOBW5AmCC09KaAbn6JP2d8cnLOGwF0piJnSbGTRPN41G7STjd4hW5AkSqcvQ9uhBysVJr52mlx4SXCkaIBvxaIOT7EHSSyd0RYO0waWxhsnohxG2NIWW9aeDqWUaf0SLpqxSf3SqQKKggUEl/bjOxo95K3g8btGzI1LcnxqaY1WpkTQNGiMyqxPWn/ULvRx4qkaGeCaNo6vRU49NvI3j97Le1lhqnkqt6faluOMykPGx16OO231Lade@fY1PkmYoSkWdyDwYPmb6L/Ef5bK85C4R9jqnRlYu@1EFjR2@AQ "Haskell – Try It Online")
Shortens [Zgarb's OG solution](https://codegolf.meta.stackexchange.com/a/10668/20260)
```
f(x:y)|(a,b)<-span(/=x)y=(x:a,b)
```
by prepending `x` to the first element of `(a,b)` in a pointfree way, that is without explicitly binding `(a,b)`.
It would be nice it we could do `(x:)<$>(a,b)`, but that gives `(a,x:b)` -- the Functor instance of tuples lets us act on the second element but not the first.
However, Applicative lets us combine tuples as:
```
(p, f) <*> (a, b) = (p++a, f b)
([x], id) <*> (a, b) = (x:a, b)
```
It suffices to use `*>` which ignores `f` and leaves `b` unchanged.
```
((x:), 0) *> (a, b) = (x:a, b)
```
The `0` could be anything -- it doesn't matter. It would also work to use `>>` in place of `*>`.
**26 bytes**
```
f(x:y)=([x],y)>>=span(/=x)
```
[Try it online!](https://tio.run/##lZTLboMwEEX3@YpZdAGSo/IwT4nsu@oHIC@Q2qhRUho1XZCvp/Y8Qg20USULhZlz7euZIW/d5fh6Oo3jPhjqa9gE7WDUNdztmsu564PHZgjH9@7QQ13D0zME4QbfGnj52ACcPw/9FzzAHtpYgV2Vge0W2jY2CkOVMT6mbUyBZsy9OVLPsUxBocA@MyZdwJEYmsGlArsiRxBcOlJCM7hAn7S/PT5hCYedUBIzod0sR/N002jSehm3Q7QiT5BIbYa2Rw9SLk46rZ9eekhwpWiAbMSTDU6yB0kvndAVc6RzXBprmEx@GGFLPrSsPx1MLdP4I1o0ZZX6o1MlEiUNDCrpx202fsxbyeNxj54dkeL@1NACq0qNpGnQGJFZ9Vh31i/0cuCpGhnimTSOrkZPPTXxPo7fy3pbY6l5KrWm21fijstAxqdeTzpu9z2lWfv2NT5JmqEoFXUi85DzMf6/xH@Uy/KSu0TY25zmsgrZjyqYm/Eb "Haskell – Try It Online")
A alternative, this time using the Monad instance and `(>>=) :: Monoid a => (a, a0) -> (a0 -> (a, b)) -> (a, b)`
**27 bytes**
```
f(x:y)=([x],[])<>span(/=x)y
```
[Try it online!](https://tio.run/##lZTJbsIwEIbvfYo59JBIps3iLCDg1EsPVR8g8iESRY0KCQIO8PSpPQtplhZVsiIy8/3275kJn@Xp62O3a6v9oTme4aU8l09vTd1UG/C85dr32613WVz9lVdcjCqMv1yfDmXtPa8u/rXdl1UNiwW8voPnP@DbCjbNA8DhWNVneIQtFKECu@YGZjMoitAoDM2N6WPaxhRoxtybI/UQSxRkCuwzYdIFHImhAZwrsCtwBMG5IyU0gDP0Sfvb4yOWcNgJJTEQ2s1SNE83DTptL@N2CCbkERKxzdD26EHKxUmn7afHHiJcMRogG2Fng5PsQdJjJ3TFFOkUl8YaRp0fRthSHxrXnw6mlmn8EYyaMkn90akciZwGBpX04zYbP@Yt5/G4Rw@OiHF/amiGVaVG0jRojMis9lh31i/0eOCpGgniiTSOrkZP3TXxPo7fy3RbQ6l5LLWm28/FHZeBjHe97nTc7ntKM/Xta3ySNEFRLOpI5iHlY/r/Ev9RjstL7iJhb3OayspkP6pgatpv "Haskell – Try It Online")
Using `<>` to do concatenate elementwise `(a, b) <> (c, d) = (a++c, b++d)`. This is available in Prelude without an import starting in version 8.4.1.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 17 14 bytes
```
sub(FS$1,RS$1)
```
[Try it online!](https://tio.run/##SyzP/v@/uDRJwy1YxVAnCEho/v9voWAEhOYKpgomQNJAwQKIzQE "AWK – Try It Online")
*Thanks to Pedro Maimere for the hint to lop off 3 bytes*
The interactions of the rules in the contest allow for pretty trivial AWK solution... Assuming the input can be a blank delimited string of numbers, this will work. If it has to include the brackets and commas (which I wasn't sure about from the linked article about convenient input), then it would be this instead.
```
sub(", "(a=substr($1,2)),"]\n["a)
```
And here's one in `><>` which might be shrinkable still... It's the first time I've managed to get something to work in that language, so I wouldn't be surprised to learn there some trick I don't know yet.
# [><>](https://esolangs.org/wiki/Fish), 41 bytes
```
i:o&0v
?(0:i<o$v?<=1:+{=&:&:;
 0+1o+19< ^
```
[Try it online!](https://tio.run/##S8sszvj/P9MqX82gjMtew8Aq0yZfpczextbQSrvaVs1KzcqaS8FA2zBf29DSRiHu/38jYzNzQyNLYwsA "><> – Try It Online")
I can add a more detail description if anyone is interested, but here's an overview of how it works.
The input it expects is a string of digits. Since the challenge specified that the list was made up of single digit numbers, I chose not to include a delimiter. If that's a requirement, some additional stuff would have to be added...
The first line reads in the first number, uses it to set the register (for comparison as the rest of the list is read in), then pushes a counter that tracks the number of times the first number has been seen. Then it passed control down to the next line.
```
i:o&0v
```
That line reads one digit at a time, starting with the second digit, and prints it. There's a conditional code to add a `\n` when the counter hits `1` (meaning it found the second occurrence of the first digit). The code is interpreted right to left to save characters.
```
?(0:i<o$v?<=1:+{=&:&:;
```
The last line is effectively like a "function" call to print a linefeed and tweak the counter so that it will never be called again.
```
0+1o+19< ^
```
[Answer]
# Vim, 3 bytes/keystrokes
```
*O<esc>
```
Jump to next occurrence of word and make a new line.
---
# [V (vim)](https://github.com/DJMcMayhem/V), 2 bytes
```
*O
```
[Try it online!](https://tio.run/##K/v/X8v//39DLiMuYy5DLksgNgQA "V (vim) – Try It Online")
Since V has implicit escape after `O` (?), we can use just 2 bytes.
---
Old (general) 8-byter:
```
Y/<C-r>"<BS><CR>O<esc>
```
---
Input is each list item on a single line. Output is two lists separated by a blank line.
Uses vim notation for the keystrokes (`<C-r>` is `Ctrl`-`R`, *etc.*; see `:help key-notation`).
Explanation:
* `Y` yank the first line
* `/<C-r>"<BS><CR>` search for the next occurrence by inserting the yanked text into a search `/`. Yanking into the search register with `"/Y` doesn't work (`:help quote/`). The backspace deletes the line-ending, which is yanked. (Alternately, use `y$/<C-r>"<CR>`.)
* `O<esc>` new blank line above.
This generalizes to any type of list as long as each element is a single line.
---
I don't think we can use POSIX vi for this, since I don't think it has `<C-r>` to insert registers. It doesn't have the search register `"/`, but that doesn't end up mattering.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~18~~ 7 bytes
```
Ṙṫ:‟€vp
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%98%E1%B9%AB%3A%E2%80%9F%E2%82%ACvp&inputs=%5B7%2C%201%2C%205%2C%207%2C%204%2C%202%5D%20&header=&footer=)
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), 11 bytes
```
{(2#*=x)_x}
```
[Try it online!](https://tio.run/##PU/LCgIxDLzvVwS8qCBs0zbtCn6Lt/Ug7HlB/PY6maiEtnlMZqbPy/bYxlivr6Mezrf9dN/fY5WEWKZViiw4SKo0nOppR8wokTbAfFJEvZzFgPfdORqKMuP2eUVOjCIy3sRDlDMYXkMU0GvoKEcVrQbsX7Xj6TSmvMNbCv6MkTtoyNyNWyzI@YsgqhhUircvV/kZSVTJVHbahbtBbiGQSJgIqBhmQpQGjcsU8i1lO75kjEa4i5pM4wM "K (ngn/k) – Try It Online")
* `(...)_x` [cut](https://code.kx.com/q/ref/cut/) the input (`x`) at...
	+ `2#*=x` the indices of the first two occurrences of the first value in the input
[Answer]
# [Factor](https://factorcode.org/), ~~37~~ 35 bytes
```
[ dup first 1 pick index-from cut ]
```
[Try it online!](https://tio.run/##hVTBTsMwDL33K8wHDG1pkhaQdkVcuCBOiMPUZVI11pW2k0BVvr3YTkOSsYlFTRO/59h5drfbVMOxm15fnp4f72HT98eqh73pGvMBvfk8maYyPbSdGYbvtqubAR6ybMwAfyOscNyBhRtYrHFLBsszGe1MkriTMUkyPLLRkxQU@KiYRibLbxURSxxLRn6JJdO82RMLTIOOkCBisjNbXjnIOyxBY2J0pWXqEgDLu9hJIJLjTEepVAsHWV4FOEQTOHJ8r/hJ4jnIRfNwiEiJa3xrHBLvLdKoDnZxY0pQUDBLIVLg4Rf0TAmX1C1xV3JhBc@ufmfdUM4VvEb0h@XIIHkLXJHUVCOJ66RrAsny7pwY2o1yVogrVq6Yc5WpyNdorjFTwVd8/ZxlofzvOKi7hT4vuie7AlxzsNEXROEEt3nOd6FAVBY9n/Pn6/rPIUhBQQWjrg80j4K96L46lSSmOyEuu9jMTm@wPbWwq7t@wHTautpD3WzN12LXHQ9QnQZ4n0bkHjbtmv9W4Hb6AQ "Factor – Try It Online")
## Explanation:
* `dup` Duplicate the input.
**Stack:** (e.g.) `{ 0 2 2 3 0 1 0 1 } { 0 2 2 3 0 1 0 1 }`
* `first` Get first element.
**Stack:** `{ 0 2 2 3 0 1 0 1 } 0`
* `1` Push `1`.
**Stack:** `{ 0 2 2 3 0 1 0 1 } 0 1`
* `pick` Put a copy of the object third from the top on top of the stack.
**Stack:** `{ 0 2 2 3 0 1 0 1 } 0 1 { 0 2 2 3 0 1 0 1 }`
* `index-from` Find the index of `0` starting from index `1` in the sequence on top of the stack.
**Stack:** `{ 0 2 2 3 0 1 0 1 } 4`
* `cut` Split a sequence in two at an index.
**Stack:** `{ 0 2 2 3 } { 0 1 0 1 }`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
œṡḢ©®;Ɱ
```
[Try it online!](https://tio.run/##VVC7DcIwEO2ZwgO4iL9JxChRShqUBWhpGIAJoENCSHTQghiELGLs93wgpJN9d37v7j2vV9O0Sem1f98P79vxcXpclvP1kp67eXtOaRiMVjn6US8Gn2@tfEmDVq1W@Qyl6rTK0eReqVowiMgUW3r5LYLNcU1tW/RcrggFra8Ei3BAk2Mqh4Mj3iPCQ4GtYsikQI@k@VPYodfRDrBMvq7EsQOKmltooQta9Oj4@jXcEgAJIpprePqfASNynIjl6l6GVg3cV0hGNhqBBwCdMKyYjBxcVXGWlffvV0WJVmZQZxzHDw "Jelly – Try It Online")
```
œṡḢ©®;Ɱ  Main Link
œṡ       Split at the first occurence of
  Ḣ      The first element (pops the element)
   ©     (also copies that element to the register)
      Ɱ  For each block
    ®;   Prepend the register
```
As pointed out by Nick Kennedy in the comments (full credit to them), `Ḣ;Ɱœṡ@¥` also works and is slightly more functionally pure (though `Ḣ` still modifies the list itself, so it's not entirely pure):
```
Ḣ;Ɱœṡ@¥  Main Link
Ḣ        Cut off and return the first element
      ¥  Last two as a dyad (for chaining; this makes the right argument the modified list for both inner dyads rather than applying consecutively)
 ;Ɱ      Prepend the first element to each of
   œṡ@   The modified list, split at the first occurrence of the first element
```
[Answer]
# [Python 3.8](https://docs.python.org/3.8/), 41 bytes
```
lambda l:[l[:(i:=l.index(l[0],1))],l[i:]]
```
[Try it online!](https://tio.run/##lZTbboJAEIbvfYq5A5JtwxkkoS@CXFhdIilVAjSxNT47XeagpTWamg3uDvPP/rP7hfZz2B32Qdp2Y5Wvxmb9/rpdQ5MVTZHZdZY3z/V@q492U7il8hynVE1RZ2U5DrofesjBLjwFZixLBUVo/hWE0zRSkCgwz2hapQrMcE1sWiWooAwj8aeYeRejmsq5HPYxFpgVpaJsyQIfR4DZpPFYQ4VjfB/jCNGBz2ZISQZDnLgzhynGUmoHc2ly6Uo6DjCLPCfohbqgFkOMhHw0tEuEKZGYpm3oGV4b8MROIGZp66UUZQ@03yTyZEdP0iNMDEThS5MxFWZXVMuX95ejimUkUoN8xqWz0MdWbwa9xfsvPN5@WU4ThABr0zLiI0UUMJLyCeNhY4SBYDYQCYzPoJBLp1cMBh/XDzREyHCwSvAQLQPC8jkiZPImJH@cp1dg7qKCyTNYmJ5buMgxPgCGL/Da1BUa7usRNiiU6/sPOuLwNzxs6S4@hp/NTm/edDfhY60@/CTcWApw5gWWs6gOHQxKQ72Hr7q18VOjQKBzsgWY3/TxqezBwUXb1fvBrqzTcIanFzj1ZzjxJoXO8748W874DQ "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~18~~ 17 bytes
```
^((.).*?)\2
$1¶$2
```
[Try it online!](https://tio.run/##FY27DcJQEATzq8NINoF1t/ePCGkCIQgISAgQtbkAGjOPeGdn3o/P83XfD/P5tl/neV3W42m5gCb5bhP2ib7bLtJkbeTpTlWclOJpII4WYRBaYfAmBpSFhZAWiLACFZBuyf9fZbWhbZiGU0skNTrF1GggHs6SA7JhkGIFPNt0wNEkYgJ3VVNwBSuNBeBRiYhUq4wf "Retina 0.8.2 – Try It Online") Link is to test suite that double-spaces the output for convenience. Takes input as a string of digits. Explanation: Simply finds the earliest next match of the first character and inserts a newline before it. Edit: Saved 1 byte thanks to @Jakque.
[Answer]
# JavaScript (ES6), 31 bytes
Thanks [Razetime](https://codegolf.stackexchange.com/users/80214/razetime) for -1 byte.
```
a=>a.match(/^(.).*?(?=\1)|.+/g)
```
[Try it online!](https://tio.run/##dVDbSsNAEH33R7pRTOc@u0jsj4iwxPSibVOaIgj@e4yvMr6eM3Nu7/WzTv31cLk9TpfD23A9jeeP4WvednPtnmt7qrd@n9avqW3a@03adC/YfLcP610z9@N5Go9Dexx3aZtWiGXVNE93f2ApEsHqqhGeM3iEO6oLRQxYQYSQosIkpGEuIGJAwPDPxchMcqiaiVzF4Z@k2XMRKrI0jBfhjOhsxVE43GbRVlNAX6QkDogZmEi9CC8uFvogCpIqszBBNuDQi5UIlqpm5izZ7fdq/gE "JavaScript (SpiderMonkey) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 17 16 bytes
```
(]{.,<@;@}.)<;.1
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NWKr9XRsHKwdavU0baz1DP9rcvk56SkYahuq1ehl6lXrcaUmZ@QrpCkY6BgBobGOgY4hCMOEDXVAyBLGNVGwVDD5DwA "J – Try It Online")
In a sentence:
*Cut on first element and then meld together the tail elements.*
Consider `f 0 2 2 3 0 1 0 1`
* `<;.1` Cut using the first element as the fret:
```
┌───────┬───┬───┐
│0 2 2 3│0 1│0 1│
└───────┴───┴───┘
```
* `{.,<@;@}.` First element of that result `{.` catted with tail of that result
`}.`, razed `;` and then reboxed `<@`.
```
┌───────┬───────┐
│0 2 2 3│0 1 0 1│
└───────┴───────┘
```
[Answer]
# **[BQN](https://mlochbaum.github.io/BQN/)**, 12 11 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
```
⊢⊔˜·∨`·»⊑=«
```
[Try it here.](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oqi4oqUy5zCt+KIqGDCt8K74oqRPcKrCgpGwqjin6gyLDcsNCw2LDIsNiw2LDQsOCwy4p+p4oC/IjI3NDYyNjY0ODIi)
Explanation:
```
⊢⊔˜·∨`·»⊑=«   # tacit function which can take input as either a list or a string
          «   # the input list shifted left
         =    # equality comparison with
        ⊑     # the first element of the input
      ·»      # shift the result right
   ·∨`        # 'or' scan
⊢⊔˜           # group the input according to those values
```
[Answer]
# [R](https://www.r-project.org/), ~~38~~ ~~37~~ 36 bytes
*Edit: -1 byte thanks to pajonk, as well as outputting the right-way-around now, and then -1 byte thanks to digEmAll*
```
function(l)by(l,cumsum(l==l[1])>1,c)
```
[Try it online!](https://tio.run/##lVTbasMwDH3fVxj2UBtciBPnUrb2R7o@dGGBQpqWpoWNsW/PbEluKi9bGTUhSOdIx0dKT0OzHJpLV593h0626vVDtrq@7PvLXrbLZbs2G7UyulZD3277Q/P2PL@i39Xn8bTrzrJxr@qp3p7l7KXzv5n6eiC8rKXRwp2FUuJRzFdi7WpqsfahzeYGZl1ACzvCfMAjLYPlWpRauGc@In3MI32UgSst3ElcegRXHklRBi5BJ9Z3vdORQhlPpBwjukoFiMebJozLkr5CEtNTSGcujLVBw41dlPdchog1pHAyEIAyDJNBedJAiFgJ3q8AaAHHgocp00MoksRwsf/YFUdm4SWZGsok8LdJVZCucGGAhi/X3eD7VtF63CGwFhnUx4GW4CpOEVfBQuRmVxnc95omxAuPbuSAzcPg8Gr4tGyI9xnwvUyM1QTPs2A0Xn0RpJEHqJrNeqTSuO@QWWsTbm8CLwdGFqhp2IcCe/z8l/gHObYXpaUBeF3SIpwyFEP7CmZ1zCZv/@I7AcM3 "R – Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/), 35 bytes
```
shift>$1
ls
for x
(rm $x&&od;<<<$x)
```
[Try it online!](https://tio.run/##qyrO@F@cWqJgoGAEhMZA2hCE/xdnZKaV2KkYcuUUc6XlFylUcGkU5SqoVKip5adY29jYqFRo/v8PAA "Zsh – Try It Online")
Explanation:
* `>$1`: create a file named the first input item
* `shift`: shift the input array, removing the first item
* `ls`: list the directory. Since we created `$1`, this prints the first item
* `for x`: for each item `$x` in the input array: `(`
	+ `rm $x`: try to remove the item. If the item `$x` is the same as the first input, and the item has not already been removed, this will succeed
	+ `&&`: if that succeeds:
		- `od`: print `0000000` as a separator
	+ `<<<$x`: print the item
With some loose interpretation of what is allowed as a separator, we could have:
## [Zsh](https://www.zsh.org/), 33 bytes
```
shift>$1
ls
for x
rm -v $x||<<<$x
```
[Try it online!](https://tio.run/##qyrO@F@cWqJgoGAEhMZA2hCE/xdnZKaV2KkYcuUUc6XlFylUcBXlKuiWKahU1NTY2NioVPz/DwA "Zsh – Try It Online")
* `rm -v` is `v`erbose; if the removal is successful, a message `removing 'x'` is printed which is arguably a separator, as well as printing the item
* `||`: if that fails:
	+ `<<<$x`: print the item. We only need to do this if removal fails, because `rm -v` prints the item already
[Answer]
# [Red](http://www.red-lang.org), 49 46 bytes
```
func[x][reduce[take/part x find next x x/1 x]]
```
[Try it online!](https://tio.run/##lVTLbtswEDybX7H1WYGtpxUD9kf0SvBASDQSxJYESSkUFP12l/ugFaVNjACEQO7M7pA7FHtXX3@6GrSBU9vur6fXptKT0b2rXyunR/viNp3tR5jg9NzU0LgJ59MmhsmYa2UHN@zht1rpOAI/Hg08HEHr2ESgaW08lvlJBJlguEI4IyyPYBeB/@YCYwBhCiGjjMCPLYaZUSIcQsjYkTZX8tUT4UkY2QFAtk8raEO85e2csEAwbRtyEgqnfsmFSC0cVkBMWMKiltBISYoF41lQQFELsGjytguiFDQyakYyKwtFxJck6R5LcJczmmz/ael/WR/7XFK4ZDeJzpObh@9uQCk23mNj3ZSKsh076hTbwAZmFAm3Z8FFgU/Ycu/4sDlx8uAAH4K/2ezGfTpd23f@xKGPaegfH@4x7ENOyVucTZvzxLd7meb2h2X0ZX5OzDSkJMHYQmov/8XvZEr3eB9JINyuVhHGLhThBhVzJz@mSuu@TDbqj1IPxz1c/LsDbfcD8D0CPcGb0W9wOOAj5R8epbr@uRlBq5U9n@Hc2hp6151t5TYYoGcJqvZysbBeq9XaV3S2GWB8siMgY3TDKLQn@8tBZ4fB1Wtlrn8B "Red – Try It Online")
[Answer]
# Scala, ~~35~~ 30 bytes
Saved 5 bytes thanks to @cubic lettuce!
```
x=>x splitAt x.indexOf(x(0),1)
```
[Try it in Scastie!](https://scastie.scala-lang.org/b01x62e7QQKGLtfD6dbEQw)
Hopefully, I'm not FGITW'ing this.
[Answer]
# JavaScript (ES6), 34 bytes
```
a=>[a,a.splice(a.indexOf(a[0],1))]
```
[Try it online!](https://tio.run/##lVTbboMwDH3fV@QRpKwlEC596H5hH4B4iChMnRBUY5r29yyxY2iatNWkCCH7HPvk2PCpftTcfp0v36/jdOqW/rio41utuNrNl@HcdpHancdT9/veR6pOGi7iuFnaaZynodsN00fUR7XgTJ9DE8dsv2esrkXDWQ2h5uUGK3WUM7lhTcDApY/NOSs50898g5uYgUPUY1Sc6ZMYzMqoDJyiHqME7dhJS0k3ns0YNuU8tq5ZwIXQgsQp4CRNmSRYIwVMpnPYBdRcmWnzpoCLCKlJ4WQgBQUJR5DNWzWECGnCOxeAL@BIMDd1lFmUFefiQtPB/jhVCS9JaGRB4MM5VoCpcLuAiy/rDrkbWtk1ekbw@mTQBMddgtM4Y9wWCZGr7XbgpuEdQug7QXNyIOQ0UbwkPqUz3ecM@MzuzVvQHDIyH504kEhrCep3lmCj2j14Rvb6CzJDEDkHWkb8lBalsI28f81/yCG3UWRK6HWPCzolVUQ3C8f5W7a1@iG/Wf4A "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 56 bytes
```
f(h:t)=(h#t)[h]
(h#(x:y))a|x==h=(a,x:y)|0<1=(h#y)$a++[x]
```
[Try it online!](https://tio.run/##lZTbaoNAEIbvfYqB5kLJBjysR@oD9KoPIF4IbTAkTUvrhYG8u92dQ6yHNhQW0Znv3/13ZpK2@Tq@nk7DsHfbovNKt33ovKqtHfPi9sXF85prX5Zt6TbKfl79x8BCF2/TbLdVXw9vzeEMRQFPz@B6Dn6V8PLuAHx8Hs4dbGAPVaDArLxej8JuB1UV1ApDeT3DtIkp0IzZL0vqORYrSBWYZ8ykDVgSQzM4U2CWbwmCM0tKaAan6JP2N8eHLOGwFUpiJjSbJWiebuqP2knG7uCvyEMkIpOh7dGDlIuTVjtNLz2EuCI0QDaC0QYn2YOkl07oignSCS6NNQxHP4ywpSm0rD8dTC3T@OIvmrJK/dGpDImMBgaV9HKbjR/zlvF43KNnR0S4PzU0xapSI2kaNEZkViesPesXejnwVI0Y8VgaR1ejpx6beB/H38t6WwOpeSS1ptvn4o7LQMbHXo86bvc95epvX@OTpDGKIlGHMg8JHzP9l/iPcllechcKe5vTRFYq@1EFk3r4Bg "Haskell – Try It Online")
Because why not?
## flawr's suggestion, 33 bytes
```
f(x:y)|(a,b)<-break(==x)y=(x:a,b)
```
[Try it online!](https://tio.run/##lZTJboMwEIbveYo59ACSkViMWVQeoKc@AOJA1ESNsrRKe0ikvju1ZwnF0EaVLBRmvt/@PTPktf/Ybw6HYdgGl/oafgW9WoeP0fq86fdB01zCa2MTLjgc@90J6hqeniEIV/jWwMvbCuD9vDt9wgNsoU0U2FV1y1GIImjbpFMYqjoP0zamQDPm3hypfSxXUCiwz5xJF3Akhjy4VGBX7AiCS0dKyIML9En72@NTlnDYCSXhCe1mBs3TTeNRO8m4HeIFeYpEZjO0PXqQcnHSaafpuYcUV4YGyEYy2uAke5D03Ald0SBtcGmsYTr6YYQtTaF5/elgapnGH/GsKYvUH50qkShpYFBJP26z8WPeSh6Pe7R3RIb7U0MLrCo1kqZBY0RmdcK6s36h5wNP1cgRz6VxdDV66rGJ93H8XpbbmkjNM6k13b4Sd1wGMj72etRxu@8pF799jU@S5ijKRJ3KPBg@Zvov8R/lvLzkLhX2NqdGViH7UQVNN3wD "Haskell – Try It Online")
This is based on Zgarb's solution (`f(x:y)|(a,b)<-span(/=x)y=(x:a,b)`).
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~60~~ 57 bytes
```
$a,$b=$args
$r=(,$a),$y
$b|%{$r[$r[1]-or$_-eq$a]+=,$_}
$r
```
[Try it online!](https://tio.run/##PUzLCsJAELvvV8whiuIutD5aL/MlspStbH1QXJ0eRGq/fZ1eJCEkIeSZ3lGGa@x7d04SMzoeM4JFywhyGQyEVxZhbfExaL@LEXJSlt4lQePiC8Fv2KKZdJono0pMS3S0px0daKsoqNJ0VJ1Raz@nmirj7un20LvC/23p8w8 "PowerShell Core – Try It Online")
It takes the input as an array of ints, returns two arrays
### Another approach for 59 bytes
```
param($a)$a[0..(($i=$a|% i*f $a[0] 1)-1)],$a[$i..$a.Length]
```
[Try it online!](https://tio.run/##PYxBDsIgEADvvGLTrIYaIaVF2gs/8AeGw8aAxdTSoIkH9e1YL95m5jBLevp8H/00iXPKvmCwr7JQphtHqpFOjZScY7RI7w3EXYBfc6BqoWq3XwWjlEjy6OfLY3TlwxhmsLDFAJXuDm3bGD0YY/pOD72pmLimOGNeJ39UrnwB "PowerShell Core – Try It Online")
Takes the input as a string, returns two arrays
[Answer]
# [Red](http://www.red-lang.org), 67 bytes
```
func[b][collect[keep/only take/part b find next b b/1 keep/only b]]
```
[Try it online!](https://tio.run/##VVFLboUwDNxzitHbV0BIAnTRQ3QbpRKfoD49CohSqT09tQ0KLRGRY49nJvEa@v019M4nwzP24WvqXOtdN49j6Db3CGFJ52n8wdY8Qro064YWw33qMYVvjts0x4Vqvd@HeQ1N947x/rnBJaDP5chR@yPWqKHP2KCEgTlPFSpkKM9TST1c11BnJoOlXubKYk5RpoBiFKHriFS0CsIxNo9YZrNUsbQ0qamozHj2omnP/vmoKFOxZyjZD8/XfQqqsqeS9Ngf@9YU63hfZjRUM@KH2fjXf3zloliIC@avhUFUmNNfr0hdgjFULwSlxK/l/qjIvUoqxz2trFI6WN36xLtlvU80oY957I9h3Z5e3lIiuEFyg2Rpor8 "Red – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 45 bytes
```
i=input()
a=i.index(i[0],1)
print i[:a],i[a:]
```
[Try it online!](https://tio.run/##HYtBCsMgFAX3nsKdWh5Fk7TQgCf5/IUkQv7GSLGQnt6mYRYDA1O/bdvL0Jd9zdEY0yVKqZ9mnUpR7lLWfFghzwhO1beUpoXmxBBKM/fzUPnIi/3/Tt/02Ckg4MWK/OkBIzwmPPC8ygX/AA "Python 2 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 26 bytes
```
g[b_,a___,b_,c___]=b.a|b.c
```
[Try it online!](https://tio.run/##RVBLboMwEN1zCh/ASvEHOywqcYTuowgZVKVZpIuKHfXZ3ckbXiqNzHh4v/GjbF@fj7Ld19La7bLMtszzbOW7yvf6vpzK73Ja28fP/Xt7m27TNHX77qyRGqux3R6lsSZWaQdrsjVyDs/b2RqpXmbAZXAUIhxfrel2@ZvAV8Wec49hkKuCQRxJ8agAvLIcLDzFEwAJFRFDZc/kasyIpv/PeWAyJiOttXkt55gkAKbJM/LoLrppxCTyjdRoAGZgcjXSMz63OHZ3jBQYWN1Hyh4x1BEsR1NH/ABkIMVz06TKDKZqnoDXiyVWpohGTbWa1v4A "Wolfram Language (Mathematica) – Try It Online")
-10 bytes thanks to @att
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~8~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ćk>Ig‚£
```
[Try it online](https://tio.run/##yy9OTMpM/f//SHu2nWf6o4ZZhxb//x9toGMEhMY6BjqGIBwLAA) or [verify all test cases](https://tio.run/##PU87CsJAFLyKpH5F9p802niLkEJBRCwsBCGdlfaWtt5EPEkuEmcmIo/dfZ95M7On82Z72E2XYVUtxttjUa2G9fS5H5fDfrw@36/Jpq5z5qztrYvWWsSbrFiyhKyxxmoryAow7EfzqGrLwHKvVu1RBfOcAtUK4REBc2KcMNzO6GZEBLOXAnHUi7jrv16DqqEf87pnT7PPgAm1C/jpg94i8qg/kCWhn6RNFp748@CkEKRKzlabYiYXME5sTvOEWRDCy1vmrlS449Wd/5IVRWgq5r7/Ag).
**7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) alternative provided by *@ovs*:**
```
ćk>°RÅ¡
```
[Try it online](https://tio.run/##yy9OTMpM/f//SHu23aENQYdbDy38/z/aQMcICI11DHQMQTgWAA) or [verify all test cases](https://tio.run/##PU@7DcJAFFsFpX5F7p800DABbZQCJApEQYGExABAzwZswAyBSVgk2A5CT3f3Pn6273Bcb3bb8XReVLPP9T6rFufl@L7t58Nz9boMj9HGrnPmrO2ti9ZaxJusWLKErLHGaivICjDsR/OoasvAcq9W7VEF85wC1QrhEQFzYpww3M7oZkQEs5cCcdSLuOu/XoOqoR/zuidPk8@ACbUL@OmD3iLyqD@QJaGfpE0Wnvjz4KQQpErOVptiJhcwTmxO84RZEMLLW@auVLjj1Z3@khVFaCrmvv8C).
**Explanation:**
```
ć       # Extract head of the (implicit) input-list; pop and push remainder-list and
        # first item separated to the stack
 k      # Get the first 0-based index of this item in the remainder-list
  >     # Increase it by 1 to make it a 1-based index
   Ig   # Get the length of the input-list
     ‚  # Pair them together
      £ # And split the (implicit) input-list into parts of that size
        # (after which the result is output implicitly as result)
ćk>     # Same as above
   °    # Pop and push 10 to the power this 1-based index
    R   # Reverse it, so we have a 1 with some leading 0s
     Å¡ # Split the (implicit) input-list at the truthy indices (or singular index in
        # this case: the 1)
        # (after which the result is output implicitly as result)
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `ṡ`, 5 bytes
```
hẆḢḣf
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=%E1%B9%A1&code=h%E1%BA%86%E1%B8%A2%E1%B8%A3f&inputs=%5B7%2C%201%2C%205%2C%207%2C%204%2C%202%2C%207%2C%203%2C%209%2C%204%2C%202%2C%207%5D%20&header=&footer=)
Explanation:
```
h      # Get the first element of the list
 Ẇ     # Split list on head, without removing it from the list
  Ḣḣ   # Get the first element from the resulting list
    f  # Flatten the rest of the resulting list
       # 'ṡ' flag - print both lists, separated by a space
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 bytes
Feels like there should be a shorter way for this, but can't seem to find it right now.
Selecting the right-hand element ensures we don't select the first letter itself, the check on the incremented variable ensures we only split once.
```
óÏ¦UÎªT°
ó        // Split the input string between char pairs where it's not true that
 Ï       // the right-hand element
  ¦      // is different than
   UÎ    // the first char of the input
     ª   // or
      T° // T, initially equals zero, plus plus.
```
[Try it here.](https://ethproductions.github.io/japt/?v=1.4.6&code=88+mVc6qVLA=&input=IjI3NDYyNjY0ODIi)
[Answer]
# [JavaScript (V8)](https://v8.dev/), 54 bytes
```
x=>[x[s="slice"](0,i=x[s](1).indexOf(x[0])+1),x[s](i)]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifZvu/wtYuuiK62FapOCczOVUpVsNAJ9MWKBCrYaipl5mXklrhn6ZREW0Qq6ltqKkDlsjUjP1fUJSZV6LhFezvp1dcAmSnZ6ZVaqRpRBvoKBjqKBjpKIAYsZqamly4VBqCVRoSUgYx0ACk5j8A "JavaScript (V8) – Try It Online")
[Answer]
# MATLAB/Octave, 63 bytes
```
function y=f(x)
l=find(x==x(1));y={x(1:l(2)-1),x(l(2):end)};end
```
[Try it online!](https://tio.run/##tVHLisMwDLznK3yrDS7EjzhJg79k6WGpEzCUtOx2S8rSb09dqerJ3tsaYYQ1Go3Gp8Pl8zqu6/QzHy7xNLObn/giqqOf4hz44v3ClRDDzf@mZHfkWmyVkAt/ZrtxDuI@pHsN8RrD@OU32/89m6Ga@IeSLEW/F1WI32f@Gi6eJZveJbO5UiNZK1m6m1y1kyxFnTC5agsTkSGN0DlM6nUwHeXVBZgGjElVpALavkCoIQywIacqcKIwB3gHYWEjXVgWmdEQC0n9pwMdYDq0F3oxebta@hEDXehJC7ugS2iphRdb@EpU1UBLQyagDLxt2RBF6xhaFqX2NPSlGfXkSBQpVNTeQKMhBk2mORxU2AJnacK/v8ZRtMSJe7m9WB8 "Octave – Try It Online")  
Outputs cell aray with 2 cells, which hold appropriate vectors. I've chosen such output because rules say 2 lists must be distinguished, not necessarily be separate variables. And outputting 2 variables turned out to give a little longer code.
Ungolfed/explained:
```
function y = f(x)
l = find( x==x(1) );   % indices of elements equal to first element
l2 = l(2);             % index of second occurence
y = { x(1:(l2-1)),...  % vector containing elements before 2nd occurence
      x(l2:end) };     % vector containing elements from 2nd occurence
end
```
---
Interestingly, it's also possible to create anonymous function that does the same, but it's 2 bytes longer:
```
@(x){x(1:find(x(2:end)==x(1),1)),x(find(x(2:end)==x(1),1)+1:end)}
```
[Try it online!](https://tio.run/##tVHLasMwELznK3SLRFWwHpbtBEP/o@QQaht8cUpTgqH0293tTjYnqbeaRcj7mJkdXd4@z7dx2170ar5W7Q7TvAx61f4wLoPpe0oZ64yxq85Xnhz/f29Tf16ux90w3@Zh/Oj3z//77Y@7Sb86qyi6kyHe67u@k5vfUqS8VTFXqq1qrKKzzlVbqygq6slVG2YEAlH4XA/NJmaHvKrQ5rknUBVQDNsVAD1HYDRgugImhCXuTxyRN/KFZYEMQyJfqj8daLmnhb08i8vD1dKLBJ6CJw3vApdgaeRMLDwlVNU8UosJkIEzlg1xsk6QZSG1E9K7ZujJgThR6GS85sEgCF5MSyAqbAEuL/2Pp0kSjWBir3Qy2w8 "Octave – Try It Online")  
It is possible to shorten it more as [flawr](https://codegolf.stackexchange.com/users/24877/flawr) noticed, resulting in **42 bytes** but it's an **Octave-only** solution, not working for MATLAB:
```
@(x){x(1:(l=find(x==x(1))(2))-1),x(l:end)}
```
[Try it online!](https://tio.run/##tVFNa8MwDL33V@RWC1yIP5O0GPY/Rg9lSSBQ0rGOEhj97akmVT3Zuy0I41jSe09Pl4/v021Y1ze1wM@izF6d0zjNvVpSwl8AZQF2BvSizvth7uG@juk0Xw@bfrpN/fCVtrv//baHzajeja4wuiMg7/VTPcnhN@XxXVc@lwq6anSFZ8hlW11h1FiTyzbEyAhIYXM12BuJneXVhTJLNQ6zDEWwXQHQUjhCY0xTwGRhkeojhaeJbGFYRmZDPF3qPx1oqaZle6mXLy9XSxtx1MWeNDQLu8SWenrxhVWyqkAtQUxgGXz6siFGxnEyLEvthPSpmfXkQIwoNNIeqNEJghXTIhMVpmAuK/Wv1USJRjB5rniE9QE "Octave – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 12 bytes
```
Fȯ:;:←¹↕≠←¹t
```
[Try it online!](https://tio.run/##yygtzv7/3@3Eeitrq0dtEw7tfNQ29VHnAjCz5P///9GmOuY6pjqmsQA "Husk – Try It Online")
no split at index builtin, but `↕` (span) helps a bit.
it's similar to xnor(and Zgarb)'s answer, but argument destructuring and functors don't exits, so it just uses a fold.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 8 bytes
```
ḣ$£¥€ƛ¥p
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B8%A3%24%C2%A3%C2%A5%E2%82%AC%C6%9B%C2%A5p&inputs=%5B7%2C%201%2C%205%2C%207%2C%204%2C%202%5D%20&header=&footer=)
This is possible in 8 bytes Imao
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
τÄ∩T╕(û▒(Ç
```
[Run and debug it](https://staxlang.xyz/#p=e78eef54b82896b12880&i=%5B1,+1,+9%5D%0A%5B4,+9,+4%5D%0A%5B5,+7,+5,+5%5D%0A%5B8,+8,+0,+7%5D%0A%5B7,+1,+5,+7,+4,+2%5D%0A%5B0,+6,+9,+1,+1,+0,+2%5D%0A%5B2,+9,+3,+2,+4,+2,+5,+9%5D%0A%5B0,+2,+2,+3,+0,+1,+0,+1%5D%0A%5B2,+7,+4,+6,+2,+6,+6,+4,+8,+2%5D%0A%5B8,+2,+2,+7,+5,+4,+7,+0,+8,+0,+7%5D%0A%5B8,+7,+8,+9,+4,+2,+9,+4,+5,+7,+5,+1,+9%5D%0A%5B3,+8,+1,+1,+7,+3,+6,+9,+7,+1,+4,+3,+4%5D%0A%5B4,+7,+0,+5,+6,+5,+0,+1,+7,+8,+7,+8,+4,+1%5D%0A%5B2,+1,+8,+0,+3,+2,+2,+5,+7,+9,+4,+3,+5,+1,+9,+6,+9%5D%0A%5B1,+1,+4,+1,+2,+5,+5,+3,+3,+4,+3,+2,+0,+8,+6,+0,+3%5D%0A%5B4,+3,+5,+2,+2,+0,+6,+4,+8,+6,+6,+6,+7,+3,+4,+8,+7,+6%5D%0A&m=2)
annoyingly long, but i guess it works.
### [Stax](https://github.com/tomtheisen/stax), 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)(regex)
```
êt┴≈∟·M╤\+6)
```
[Run and debug it](https://staxlang.xyz/#p=8874c1f71cfa4dd15c2b3629&i=%22119%22%0A%22494%22%0A%225755%22%0A%228807%22%0A%22715742%22%0A%220691102%22%0A%2229324259%22%0A%2202230101%22%0A%222746266482%22%0A%2282275470807%22%0A%228789429457519%22%0A%223811736971434%22%0A%2247056501787841%22%0A%2221803225794351969%22%0A%2211412553343208603%22%0A%22435220648666734876%22&m=2)
### [Stax](https://github.com/tomtheisen/stax), 22 bytes(tsh's regex)
```
"^(.).*?(?=\1)|.+$"|Fm
```
[Run and debug it](https://staxlang.xyz/#c=%22%5E%28.%29.*%3F%28%3F%3D%5C1%29%7C.%2B%24%22%7CFm&i=%22119%22%0A%22494%22%0A%225755%22%0A%228807%22%0A%22715742%22%0A%220691102%22%0A%2229324259%22%0A%2202230101%22%0A%222746266482%22%0A%2282275470807%22%0A%228789429457519%22%0A%223811736971434%22%0A%2247056501787841%22%0A%2221803225794351969%22%0A%2211412553343208603%22%0A%22435220648666734876%22&m=2)
]