[Question]
  [
Inspired by [this Math.SE question](https://math.stackexchange.com/questions/2560570/do-fibonacci-numbers-reach-every-number-modulo-m).
# Background
The [Fibonacci Sequence](https://en.wikipedia.org/wiki/Fibonacci_number) (called `F`) is the sequence, starting `0, 1` such that each number (`F(n)`) (after the first two) is the sum of the two before it (`F(n) = F(n-1) + F(n-2)`).
A Fibonacci Sequence [mod](https://en.wikipedia.org/wiki/Modular_arithmetic) K (called `M`) is the sequence of the Fibonacci numbers mod K (`M(n) = F(n) % K`).
It can be shown that the Fibonacci Sequence mod K is cyclic for all K, as each value is determined by the previous pair, and there are only K2 possible pairs of non-negative integers both less than K. Because the Fibonacci sequence mod K is cyclic after its first repeated pair of terms, a number which doesn't appear in the Fibonacci Sequence mod K before the first repeated pair of terms will never appear.
For K = 4
```
0 1 1 2 3 1 **0 1** ...
```
For K = 8
```
0 1 1 2 3 5 0 5 5 2 7 1 **0 1** ...
```
Notice that for K = 8, 4 and 6 do not appear before the repeated `0 1`, so 4 and 6 will never appear in the Fibonacci Sequence mod 8. 
# Challenge
Given an integer K strictly greater than 0, output all of the non-negative integers less than K that *do not* appear in the Fibonacci Sequence mod K.
# Rules
* [Default loopholes are forbidden](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default).
* [Default I/O](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
* [Programs or functions are acceptable](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet).
* You can assume that *K* will fit in your native integer type ([within reason](https://codegolf.meta.stackexchange.com/a/8245/44694)).
* If there are non-negative numbers less than K that do not appear in the Fibonacci Sequence mod K, your program/function should output all such numbers in any reasonable manner.
* If there are no non-negative integers less than K that do not appear in the Fibonacci Sequence mod K, your program/function may indicate this by returning an empty list, printing nothing, producing an error, etc.
* Order does not matter.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in each language wins.
# Test Cases
[Generate test cases online!](https://tio.run/##bU/RDoIwDHyGr2hMSIaiGWh8MNEfWRaCbkgBuzlHjF@P4wlMfGiTu17vWvvxjaFiHJWuocbr1VB1u2H5MKrsSm9Cez2HymnFuvQUR@8Gew3d@giXM/Sa2LwzjaMZ7iprNamFQGxzuVnCQqZx5LQfHIHApIPaOEBAWlwiTiFMynhm4AyCZ3mggrqd1Eh28GzKtw7Jwyop1Cpps2A6W7qK7pq1KWAdCDL@N@ffx20qx1HknGdFqH2oA@fyCw "Python 2 – Try It Online")
## Non-Empty Test Cases
```
  8 [4, 6]
 11 [4, 6, 7, 9]
 12 [6]
 13 [4, 6, 7, 9]
 16 [4, 6, 10, 12, 14]
 17 [6, 7, 10, 11]
 18 [4, 6, 7, 9, 11, 12, 14]
 19 [4, 6, 7, 9, 10, 12, 14]
 21 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 19]
 22 [4, 6, 7, 9, 15, 17, 18, 20]
 23 [4, 7, 16, 19]
 24 [4, 6, 9, 11, 12, 14, 15, 18, 19, 20, 22]
 26 [4, 6, 7, 9, 17, 19, 20, 22]
 28 [10, 12, 14, 16, 18, 19, 23]
 29 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27]
 31 [4, 6, 9, 12, 14, 15, 17, 18, 19, 22, 25, 29]
 32 [4, 6, 10, 12, 14, 18, 20, 22, 26, 28, 30]
 33 [4, 6, 7, 9, 15, 17, 18, 20, 24, 26, 27, 28, 29, 31]
 34 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27, 28, 30]
 36 [4, 6, 7, 9, 10, 11, 12, 14, 16, 18, 20, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32]
 37 [9, 10, 14, 17, 20, 23, 27, 28]
 38 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 36]
 39 [4, 6, 7, 9, 15, 17, 19, 20, 22, 24, 30, 32, 33, 35]
...
200 [4, 6, 12, 14, 20, 22, 28, 30, 36, 38, 44, 46, 52, 54, 60, 62, 68, 70, 76, 78, 84, 86, 92, 94, 100, 102, 108, 110, 116, 118, 124, 126, 132, 134, 140, 142, 148, 150, 156, 158, 164, 166, 172, 174, 180, 182, 188, 190, 196, 198]
...
300 [6, 18, 30, 42, 54, 66, 78, 90, 102, 114, 126, 138, 150, 162, 174, 186, 198, 210, 222, 234, 246, 258, 270, 282, 294]
...
400 [4, 6, 10, 12, 14, 20, 22, 26, 28, 30, 36, 38, 42, 44, 46, 52, 54, 58, 60, 62, 68, 70, 74, 76, 78, 84, 86, 90, 92, 94, 100, 102, 106, 108, 110, 116, 118, 122, 124, 126, 132, 134, 138, 140, 142, 148, 150, 154, 156, 158, 164, 166, 170, 172, 174, 180, 182, 186, 188, 190, 196, 198, 202, 204, 206, 212, 214, 218, 220, 222, 228, 230, 234, 236, 238, 244, 246, 250, 252, 254, 260, 262, 266, 268, 270, 276, 278, 282, 284, 286, 292, 294, 298, 300, 302, 308, 310, 314, 316, 318, 324, 326, 330, 332, 334, 340, 342, 346, 348, 350, 356, 358, 362, 364, 366, 372, 374, 378, 380, 382, 388, 390, 394, 396, 398]
...
```
## Empty Test Cases (no output, error, empty list, etc. is acceptable output)
```
1, 2, 3, 4, 5, 6, 7, 9, 10, 14, 15, 20, 25, 27, 30, 35 ... 100 ...
```
### Related:
[Counting Fibonacci Orbits](https://codegolf.stackexchange.com/q/147200/)
[Find the Pisano Period](https://codegolf.stackexchange.com/questions/8765/find-the-pisano-period)
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 8 bytes
```
²RÆḞ%ḟ@Ḷ
```
[Try it online!](https://tio.run/##ARsA5P9qZWxsef//wrJSw4bhuJ4l4bifQOG4tv///zg)
Based on the pisano period `p(n) <= 6n` from [A001175](https://oeis.org/A001175). Also, `p(n) <= 6n <= n^2` for `n >= 6` and `p(n) <= n^2` for `n < 6`. Saved this byte thanks to Dennis.
[Answer]
# [Haskell](https://www.haskell.org/), 70 bytes
*Some amount of bytes saved thanks to Esolanging Fruit*
*8 bytes saved thanks to Laikoni*
```
a=1:scanl(+)1a
f x=[u|u<-[2..x-1],and[mod b x/=u|(_,b)<-zip[1..x^2]a]]
```
[Try it online!](https://tio.run/##DcpBDoMgEADAe1/BEVKhWY9EHtA3EGzWipWIq1FJiPHv2DnPiPvkYywFDej9ixT5UwA@BpaNTVdqpK2VyhJchdTbeelZx/LLpIt/qk408gyrhf9oa4fOlRkDmXULdPCBA2j9psP//CZEuQE "Haskell – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), ~~43 42 39~~ 32 bytes
```
{^$_ (-)(1,1,(*+*)%$_...->\a,\b{!a&&b==1})}
```
[Test it](https://tio.run/##rZbbTttAEIbv/RRbxMEGx3h37LXdCNRe9K53rapKQBEHU6EmYMWmKkp5djr/eG3c4NBW6oWT3Z3D/vPNrpOqXMzs411dqu82uph683u1fXF7WaqDx@WXzVPlTwJfhzr0d/d2g63N0yiKJofHZ@Hx@fLV2fb2@cGBfggeHjnsTTmvmnt1oNhfmVBRqJJQpaGyocpCVYRKx/zwmuZFw2ODbzYRjymFPQ7UZ1WXjR@IkjdNWTeccXZ9U9Z@EH1dlJW/f3y5H0Tzs@q1Wu5F9d153Sz8OKQgVN0sCaJ3n96@jz6UzYOH2j5ynqlXzc5uXM49J3fqXd0u1M92EvJArJND5W9e31R3TbhZ/qjKi6a8DNTSU@q6nlyWZTW7V4DknHjn3i1UG@1idDVv/J2tmOqdQErqXaJv5X0d1bcLLjPYmHoPj0rl6ojB2BNPad0OW2hYMOpIDLRqsN2CgDWAi@WM/cVJljWW8mEoFof@xYpxmMzoEWMf3bZSQwG2gyhjVgJSZ8zRczi0ZWQuTmKSLqYYyZ7Dyx0YA2@7skO26sDVPhXh9umyEByKfyjqt@2RgJ@kO7ucjPRQ/DDDMNq4CJRL5nnfOkDOlW0mx8WAO71E1Kmx7U1CkGEfQtcp@V9lDtXYPyS1K6UME3UqC3fnOY7QMeIjO3w/ZC6eus3hk/9lNS9V8gwTBPDDPoQ7RsUa1sOEiVPfBaYnHr8VPRPHfV@dpj4kdyFsIx4nbEt4nLItRQjbLI8t2zIeZxDA45xtOU4W24pEXpD4QPYYZbYMsKFUDWUaNWpo04RpIkxFD1xSTFO4pJha6ZicAbhkcg7hkmOaC0pMC7mqeVsooVBHGlUlXRVOddGL1E@C@s3t00ZtUsajhZM0C9SAxkCfAQwDLaZI2s2TAeV4hLQdoW2eE0f2Z9STEfLxOH27rgVmTR8EwGgzknUdide1xY71BgwAIBYawAA2RuDIhTQ9ZDn@FHe4wclAn0me6MvPs7y15PWCqRW@sNq@N5ncqLzrErAZ6DNF2zR8SDvQD@gjUCMttx8XCehITpLcK1AjaV57vbAGagRqBGkEdJTKXwZMQY0gjYCOoI9AjUCNII2AjqCPQI1AjSCNgI7csf4F "Perl 6 – Try It Online")
```
{^$_∖(1,1,(*+*)%$_...->\a,\b{!a&&b==1})}
```
[Test it](https://tio.run/##rZbbTtwwEIbv8xQu4pBACLEncZIiEL3oXe9aVZWAogVChcoh2oSqK8p9n6AP2BfZzj9xsukeaCv1Iru25@B/vrGzW5XjGzt9qEv1xUYX@97tRG1e3F@W6mD6@HH97Of3H74Odehv72wHG@tnURTtHp6MwpPzxxejzc3zgwP9FDxNOeqovK2aiTpQ7K9MqChUSajSUNlQZaEqQqVjfnhN86LhscE3m4jHlMIeB@qDqsvGD0TIUVPWDWe8ub4raz@IPo3Lyt87udwLottR9VI97kT1w3ndjP04pCBU3SwJotfvX72J3pbNk4fS3nGefa@6Gd25nDtO7r53dT9W39pJyAOx7h4qf/36rnpowvXya1VeNOVloB49pa7r3cuyrG4mCoycE@/cu4VqrV2Mrm4bf2sjpnorkJJ6l@hzOamj@n7MZQZr@97TVKlcHTMYe@oprdthCw0LRh2LgeYNtlsQsAZwsZyxvzjJssZSPgzF4tC/mDMOkxm9xNhHt63UUIDtIMqYuYDUGXP0HA5tGZmLk5ikiymWZM/h5Q6Mgbed2yGbd@BqZ0W4fbosBIfiH4r6bXsk4Cfpzi4nIz0UP8wwjDYuAuWSWexbB8i5ss3kuBhwp@eIOjW2vUkIMuxD6Dol/6vMoRr7h6R2rpRhok5l4e48xxE6Rnxkh@@HzMVTtzl88r@s5rlKFjBBAD/sQ7hjVKxgPUyYOPVdYHrq8VvRM3Hc99Vp6kNyF8I24nHCtoTHKdtShLDN8tiyLeNxBgE8ztmW42SxrUjkBYkPZI9RZssAG0rVUKZRo4Y2TZgmwlT0wCXFNIVLiqmVjskZgEsm5xAuOaa5oMS0kKuat4USCnWkUVXSVeFUF71IPRPUb25nG7VJGY8WTtIsUAMaA30GMAy0mCJpN08GlOMlpO0S2maROLIvUE@WkI@X07erWmBW9EEALG1Gsqoj8aq22GW9AQMAiIUGMICNEThyIU0PWY4/xR1ucDLQZ5IZffl5lreWvF4wtcIXVtv3JpMblXddAjYDfaZom4YPaQf6AX0EaqTl9uMiAR3JSZJ7BWokzWuvF9ZAjUCNII2AjlL5y4ApqBGkEdAR9BGoEagRpBHQEfQRqBGoEaQR0JE71r8A "Perl 6 – Try It Online")
```
{^$_∖(1,1,(*+*)%$_...{!$^a&&$^b==1})}
```
[Test it](https://tio.run/##rZbPTttAEMbvfootCmCDMd4de20XUdFDb721qipRQJSYCjWAFZuqKOXeJ@gD9kXS@cZrxw0JbaUenOzu/NlvfrPrpCqnEzu/q0v1xUYXB971vdq6uB2X6nA@Ox2d/fz@w9ehDv2d3Z1gc3QWRdHs2ej0fGtrdPrx8FA/BA9zDjkqr6vmXh0qdlYmVBSqJFRpqGyoslAVodIxP7ymedHw2OCbTcRjSmGPA/Ve1WXjB6LiqCnrhjNOrm7K2g@iT9Oy8vc/jPeD6Pq8eq5mu1F997Fupn4cUhCqbpYE0at3L19Hb8rmwUNdbznPgVdNzm9czl0n98C7vJ2qb@0k5IFY914of3R1U9014aj8WpUXTTkO1MxT6qreG5dlNblXAOSceOfeLVQb7WJ0ed3425sx1duBlNS7RJ/L@zqqb6dcZrBx4D3MlcrVMYOxJ57Suh220LBg1LEYaNlguwUBawAXyxn7i5Msayzlw1AsDv2LJeMwmdErjH1020oNBdgOooxZCkidMUfP4dCWkbk4iUm6mGJF9hxe7sAYeNulHbJlB652UYTbp8tCcCj@oajftkcCfpLu7HIy0kPxwwzDaOMiUC6Zx33rADlXtpkcFwPu9BRRp8a2NwlBhn0IXafkf5U5VGP/kNQulTJM1Kks3J3nOELHiI/s8P2QuXjqNodP/pfVPFXJI0wQwA/7EO4YFWtYDxMmTn0XmJ54/Er0TBz3fXWa@pDchbCNeJywLeFxyrYUIWyzPLZsy3icQQCPc7blOFlsKxJ5QeID2WOU2TLAhlI1lGnUqKFNE6aJMBU9cEkxTeGSYmqlY3IG4JLJOYRLjmkuKDEt5KrmbaGEQh1pVJV0VTjVRS9SLwT1m9vFRm1SxqOFkzQL1IDGQJ8BDAMtpkjazZMB5XgFabuCtnlMHNkfUU9WkI9X07frWmDW9EEArGxGsq4j8bq22FW9AQMAiIUGMICNEThyIU0PWY4/xR1ucDLQZ5IFffl5lreWvF4wtcIXVtv3JpMblXddAjYDfaZom4YPaQf6AX0EaqTl9uMiAR3JSZJ7BWokzWuvF9ZAjUCNII2AjlL5y4ApqBGkEdAR9BGoEagRpBHQEfQRqBGoEaQR0JE71r8A "Perl 6 – Try It Online")
```
{^$_∖(1,1,(*+*)%$_...!*&*==1)}
```
[Test it](https://tio.run/##rZbNbtNAEMfvfoqlSmmcuq53x17bREHlwI0bCCGVUpXGRRVJG8UuIiq98wQ8IC8S5j9eOyYfBSQOTnZ3PvY/v9l1MivmE7u8Kwv1xYaXQ2@6UE8vb8eFGi3vP/TOf37/0deBDvqDw4G/3zsPw/DJ4OlgNNL@w5J9T4rprFqokWIvZQJFgYoDlQTKBioNVB4oHfHDa5oXDY8NvtlEPKYE9shX71RZVH1ftj@pirLijJPrm6Ls@@GneTHrH78fH/vh9GL2TN0fhuXdx7Ka96OA/EA1s9gPX7598Sp8XVQPHgp6w3mG3mxyceNyHjq5Q@/qdq6@1ZOAB2I9eq76veub2V0V9Iqvs@KyKsa@uveUui6PxkUxmywUyDgn3rl1C9RevRheTav@wX5E5YEvJbUu4ediUYbl7ZzL9PeG3sNSqUydMhh75imt62ENDQtGnYqB1g22WRCwBnCxnLK/OMmyxlLWDcVi1z9fM3aTGb3F2EbXrdRQgO0gypi1gMQZM/QcDnUZqYuTmLiJybdkz@DlDoyBt13bIV134GpXRbh9miwEh/wfivpteyTgJ27OLicj3RXfzdCNNi4C5ZLZ7FsDyLmyzWS4GHCnx4g6Nba@SQgy7EPoOsX/q8yuGvuHpHatlG6iRmXu7jzHETpGfGS774fUxVOzOXyyv6zmsUo2MEEAP@xDuGOU72DdTRg79U1gcubxu9AzUdT21WlqQzIXwjbiccy2mMcJ2xKEsM3y2LIt5XEKATzO2JbhZLEtj@UFiQ9kj1BmzQAbStVQplGjhjZNmMbCVPTAJcE0gUuCqZWOyRmASyrnEC4ZppmgxDSXq5rVhRIKdaRRVdxU4VTnrUi9EtRublcb1UkZjxZO0ixQAxoDfQYwDLSYPK43jzuUoy2k7RbaZpM4sm9Qj7eQj7bTt7taYHb0QQBsbUa8qyPRrrbYbb0BAwCIhAYwgI0ROHIhTQtZjj9FDW5wMtBn4hV9@XmWt5a8XjC1whdW2/YmlRuVNV0CNgN9Jq@bhg9pB/oBfQRqpOX24yIBHclJknsFaiTNq68X1kCNQI0gjYCOEvnLgCmoEaQR0BH0EagRqBGkEdAR9BGoEagRpBHQkTvWvwA "Perl 6 – Try It Online")
## Expanded:
```
{  # bare block lambda with implicit parameter ｢$_｣
  ^$_               # Range upto and excluding the input
  ∖                 # set minus (U+2216)
  (                 # generate the Fibonacci sequence mod k
    1, 1,           # seed the sequece (can't be 0,1)
    ( * + * ) % $_  # add two values and modulus the input (lambda)
    ...             # keep doing that until
                    # it matches 0,1
    !*              #   negate the first param (1 when 0)
    &               #   and Junction
    *               #   second param
    == 1            #   both match 1
  )
}
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 48 bytes
```
01\
?!\:&+{:}%:1$0p&$:
v0\~:1=?
>?!;1-::0g?!nao:
```
[Try it online!](https://tio.run/##S8sszvj/38AwhsteMcZKTbvaqlbVylDFoEBNxYqrzCCmzsrQ1p7Lzl7R2lDXysog3V4xLzHf6v///7plxuYA "><> – Try It Online")
Takes input through the -v flag. 
Prints a lot of excess newlines, but gets the job done. This basically uses the first line to store the set of numbers that have appeared so far in the sequence.
### How It Works:
```
01\    Input is already on the stack
...... Initialises the sequence with 1 and 0
...... Goes to the second line
......
......
..\:&+{:}% Gets the next number in the modded Fibonacci sequence while preserving the previous number
......
......
......
..........:1$0p&$: Puts a 1 at that cell number on the first line
.......
.......
......             If the number is a 0 go to the third line
?!\..............: Check if the next number is a 1, meaning we've reached the end of the sequence
v0\~:1=?           Go to the fourth line if so
>.....             Re-add the 0 and go back to the second line if not
......           While input:
......             Get the cell from the first line
......             If not 0: print the number
>?!;1-::0g?!nao:   Finally, print a newline and decrement the input
```
[Answer]
# [Python 2](https://docs.python.org/2/), 69 bytes
```
m=input();r=set(range(m))
a=b=1
exec"a,b=b,a+b;r-={a%m};"*m*6
print r
```
[Try it online!](https://tio.run/##HcxLCsMgEADQ/ZwiCAW1KTgGQkDmMJoObRYamVpoKT27/ewfrz7bdS@@r/uZSSnVM22l3ps2QejGTUssF9bZGIiUCIEfvKo4JkpjPKYgJ3rFQ34HZbOdocpW2iD9O/3l8Hvt0hEWQAT0gBPgDN45mJz7AA "Python 2 – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~19~~ 18 bytes
```
0lbU:"yy+]vG\G:qX~
```
[Try it online!](https://tio.run/##y00syfn/3yAnKdRKqbJSO7bMPcbdqjCi7v9/QwA "MATL – Try It Online")
-1 byte thanks to Guiseppe.
```
  bU:"   ]         % Do K^2 (>6K) times.
0l    yy+          %  Fibbonaci
                X~ % Set exclusive difference between
          vG\      %  the fibonacci numbers mod K
             G:q   %  and 0...K-1
```
[Answer]
# [Python 3](https://docs.python.org/3/), 91 bytes
```
lambda n:{*range(n)}-{*f(n*n,n)}
f=lambda c,m,l=[1,0]:f(c-1,m,[(l[0]+l[1])%m]+l)if c else l
```
[Try it online!](https://tio.run/##LYxBCsMgEADvecVeCmoNKLkJvsR6sFbtgm6CzaWEvt0G2tsMDLO99@dKyyj2Nmpo90cAMofogUpixD/zITIjQfLkKdt/EmWT1TotlTeZxVmf7lh1yl@r055f2gkcM0RI9ZWgjrx2QECC33lR3EywdaSdoQRRGHI@vg "Python 3 – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~13 12~~ 10 bytes
Thanks @Zgarb for -2 bytes!
```
-U2m%⁰İfŀ⁰
```
Prints an empty list in case all integers appear, [try it online!](https://tio.run/##yygtzv7/XzfUKFf1UeOGIxvSjjYA6f///xsZGAAA "Husk – Try It Online")
### Explanation
```
-U2m%⁰İfŀ⁰  -- named argument ⁰, example with: 8
-           -- difference of
        ŀ⁰  -- | lowered range: [0,1,2,3,4,5,6,7]
            -- and
      İf    -- | Fibonacci sequence: [1,1,2,3,5,8,13,21,34,55,89,144,233,377…
   m%⁰      -- | map (modulo ⁰): [1,1,2,3,5,0,5,5,2,7,1,0,1,1…
 U2         -- | keep longest prefix until 2 adjacent elements repeats: [1,1,2,3,5,0,5,5,2,7,1,0,1]
            -- : [4,6]
```
[Answer]
# [Python 3](https://docs.python.org/3/), 78 bytes
```
def m(K):M=0,1;exec(K*6*'M+=sum(M[-2:])%max(K,2),;'+'print({*range(K)}-{*M})')
```
[Try it online!](https://tio.run/##FctLCoAgFADAq7QJ3zMD@9Ci6ATiCaJFlH0WmpRBEZ3daj2Mvdy8msz7QY2BBoGlrDlLKnWqHgQtKJFRvR8aZBOnZYuh7k4QLEVWkYjYbTEObrp1ZlJffuKbygcJeg2/LMYeDhDR55y/ "Python 3 – Try It Online")
Prints a set, so the output for empty test cases is `set()`, which is the empty set.
[Answer]
# R, ~~92~~ 86 bytes
Thanks to [@Giuseppe](https://codegolf.stackexchange.com/users/67312) for saving 6 bytes!
```
function(k,n=!!0:2){while(any((z=tail(n,2))-n[1:2]))n=c(n,sum(z)%%k);setdiff(1:k-1,n)}
```
[Try it online!](https://tio.run/##FchBCoMwEEbhvbdwIcwPEUzoogZykuJC1MEQnUKNFBXPHnXz8Xi/xC7xKl30X6GgxOV5ZQ2O/@ingVrZiHYXWz@RKAOU8tHWNIC47j7LOtMOFEXIliH2npm0DaVWgjPdjYzp9fB@0DXSBQ)
Pretty straightforward implementation (**previous version**, but same concept):
```
function(k,
         K=1:k-1,      #Uses default arguments to preset variables for legibility 
         n=c(0,1,1)){  #(wouldn't change byte-count to put them in the body of the function)
    while(any((z=tail(n,2))!=n[1:2])) #Do as long as first 2 elements are not identical to last 2 elements
        n=c(n,sum(z)%%k) #Built the fibonacci mod k sequence
    K[!K%in%n] #Outputs integers < k if not in sequence.
}
```
[Answer]
# Python 3,~~173~~ ~~152~~ ~~143~~ 131 bytes
```
f=lambda n,m,a=0,b=1:a%m if n<=0else f(n-1,m,b,a+b)
p=lambda n,i=2,y={0}:y^{*range(n)}if f(i,n)==1>f(i-1,n)else p(n,i+1,y|{f(i,n)})
```
Special Thanks to @ovs.
[Try It Online](https://tio.run/##VYxBCsIwEEX3niIbYcamkLQutDgeRUi00UA7htpNqD17DBWUrmYe/78f4vh4cl1el5uSo8709mYEy14aUtKSbsy2F94JPpFqu1crHHCpc26lKSxuwt/xVMlIk5qbeJl2g@F7C4xzlh14yUikz/nLNuMyFSBLhZbxPX0bM6YweB4BAlQaMc//8LjCer/Gw7qsVOb0AQ)
How Does It Work? 
The first function takes two parameters m and n, and it returns the nth Fibonacci number mod m. The second function loops through the Fibonacci numbers mod k and checks if 0 and 1 are repeated. It stores the numbers in a list and compares it with a list containing the numbers 1-n. The duplicate numbers are removed and the remaining numbers are returned. 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
L<InLÅfI%K
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fx8Yzz@dwa5qnqvf//4ZmAA "05AB1E – Try It Online")
-3 bytes thanks to Emigna.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 47 bytes
```
->n{a=b=1;[*1...n]-(1..n*n).map{a,b=b,a+b;a%n}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOtE2ydbQOlrLUE9PLy9WVwNI52nlaerlJhZUJ@ok2SbpJGonWSeq5tXW/i9QSNPTMLbU/A8A "Ruby – Try It Online")
While it uses some of the same logic, this is not based off [G B's Answer](https://codegolf.stackexchange.com/a/153776/31203).
## Explanation:
```
->n{
  a=b=1;   # start sequence with 1,1
  [*1...n] # all the numbers from 1 to n-1 as an array
           # 0 is excluded as it should never be in the final answer 
  -  # set operation; get all items in the first set and not in the second
  (1..n*n).map{ # n squared times
    a,b=b,a+b;  # assign next fibonacci numbers 
    a%n         # return a fibonacci number mod n
  }    # Map to an array
}
```
[Answer]
# Common Lisp, 106 bytes
```
(lambda(k)(do((a 1 b)c(b 1(mod(+ a b)k)))((=(1- b)0 a)(dotimes(i k)(or(member i c)(print i))))(push a c)))
```
[Try it online!](https://tio.run/##FYxJCsQwDAS/omOLITC@5DaPkReIcBQbO/N@R7l1QVelU2dfWDjFYhZURm6AUKDICZECrGV8SJwrMwM/hM3hS/J@b7UyoeRiG7BisQxSSow@9LpJ@ZX6fx6eSL5X2Hk9)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 bytes
```
ʁ⁰²ɾ∆f⁰%F
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLKgeKBsMKyyb7iiIZm4oGwJUYiLCIiLCIxNiJd)
## How?
```
ʁ⁰²ɾ∆f⁰%F
           # (implicit input)
ʁ          # Exclusive zero range [0, n)
 ⁰²        # Input squared
   ɾ       # Inclusive one range [1, n]
    ∆f     # Nth fibonacci number (implicit vectorization)
      ⁰%   # Modulo with input
        F  # Remove all values from this list in the other list
```
[Answer]
# [Elixir](https://elixir-lang.org/),  ~~148~~ 144 bytes
```
 fn x->Enum.to_list(1..x-1)--List.flatten Enum.take_while Stream.chunk(Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end),2),&Enum.sum(&1)!=1end
```
[Try it online!](https://tio.run/##TY3BasMwEER/RckhSFQSUegpEN96KBR66AcYk6ycJdJaWCvq4vrbHcftIZeBNzPMQMAB@9mL0@xJDKZ6oxItd3XAzNJZOxinjPlYyPrQMAOJv0pzg/r7igHEF/fQRHu@FrrJfyjku3CRo9Nu0p7GpGky1dhDlEkPSo@k0wtNE9BF6YPSu3U0lyh3Tm1ObvHn90/bAme53SrxWz1ukFq7aHzGrkZiaKF/mN7KtYuUE5xZBozIR3FE8kjIP2u47KbCeX7d7@8 "Elixir – Try It Online")
Not an especially competitive answer, but was really fun to golf! Elixir is a pretty readable language, but an explanation for the the mess of characters in the middle follows.
---
This explanation is in two sections, the mod-fibonacci and the operating on it
Mod-fib:
```
Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end)
```
This returns an infinite stream of fibonacci mod `x`. It starts with an accumulator `{1,1}`, and applies the following operation ad infinitum: given accumulator `{p,n}`, output `p mod x` to the stream. Then, set the accumulator to `{n,p+n}`.
The rest:
```
fn x->                              Define a fxn f(x) that returns
  Enum.to_list(1..x-1)--            The numbers from 1..x-1 that are not in
  List.flatten                      The flattened list constructed by
    Enum.take_while                 Taking from mod-fib until
      Stream.chunk(                 A 2-size chunk
        Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end) (of mod fib)
        ,2)
      ,&Enum.sum(&1)!=1             sums to 1, representing [0,1] or [1,0]
end
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 153 bytes
```
 k =input
 a =table()
 y =1
i z =remdr(x + y,k)
 a<z> =1
 x =y
 y =z
 i =lt(i,k * 6) i + 1 :s(i)
o output =eq(a<o>) lt(o,k) o
 o =lt(o,k) o + 1 :s(o)
end
```
[Try it online!](https://tio.run/##NYxBDoIwFET3/xSzbIUNxpho@NylhC6a1n6FkkAvXyrG5eS9N0uUUcKtFHiwi@81EQw4mTFYpQk7uCOHDJ7ta5rVhgZ76ysxfR6@EBt4P8VMcOCQlGs9LrjrOht0eC7KaRLImuo/2H6U6WXQqKrULwhBzvC3/pFosnEq5fo4AA "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~55~~ 53 bytes
```
->n{*a=0,b=1;(n*n).times{a<<(b+=a[-2])%n};[*1...n]-a}
```
[Try it online!](https://tio.run/##DcbRCoMgFADQX5FAUNPLrMeyfYj4cGUL9tAlssBhfrvbeTrHFb9tdc0sVBS6h47OToIUSTg/2zsVnGcRe4feDEFyqpNXFgAoGKxN/DtaCRvu5c73fp2JdfzFzMJ46rjPmq0@B/XUobYf "Ruby – Try It Online")
[Answer]
# JavaScript (ES6), 84 bytes
```
f=(n,a=0,b=1,q=[...Array(n).keys()])=>a*b+a-1?f(n,b,(a+b)%n,q,q[b]=0):q.filter(x=>x)
```
[Answer]
# Python 3, 76 bytes
```
def t(n,r=[1]):
 while n*n>len(r):r+=[sum(r[-2:])%n]
 return{*range(n)}-{*r}
```
This simply looks over the longest possible cycle of Fibonnaci numbers (n^2), and creates a list of all numbers that occur in that time. To simplify logic the numbers are stored modulo n.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 49 bytes
```
n->[k|k<-[0..n-1],prod(i=0,n^2,k-fibonacci(i)%n)]
```
[Try it online!](https://tio.run/##DctBCoAgEEDRqwxB4MBMaLSsLhIFZRiDMIq07O7m5i8e/HwW4SfXAAtU5XWLX5x5s8Og7HbKJd1GFkt6jBQ5yJX09F6MYK@415CK0bY6gskS5CL6NuiA15ZgFBHrDw "Pari/GP – Try It Online")
]