[Question]
  [
**Background:**
Take this input as an example:
```
1 1 2 1 1 2 1 3 1 3
```
If you look only at the first few digits, between `1 1 2` and `1 1 2 1 1 2 1`, this input appears to consist of the pattern `1 1 2` repeating indefinitely. This would make its period 3, as there are 3 numbers in the pattern.
Given only the first number, the period appears to be 1, as only the number `1` is in the input. Given the first two numbers, it still appears to be the number `1` repeating, so the period does not change.
**Task:**
Given an array of numbers (or strings, or similar), determine the period of each prefix of the array, and return the unique ones. For example, the above input would have periods of:
```
1 1 3 3 3 3 3 8 8 10
```
Thus, the output would be:
```
1 3 8 10
```
**I/O:**
Input should be an array of any set of a large number of different values. For example, numbers, strings, natural numbers, or pairs of integers. Booleans wouldn't be allowed, but chars/bytes would.
Output can be any reasonable representation of the numbers, such as an array/list, or a string with the numbers joined by newlines.
**Test cases:**
```
1                     ->  1
1 2 1 1 2 1           ->  1 2 3
1 1 2 1 1 2 1         ->  1 3
1 2 1 2 1 2 1 2 4     ->  1 2 9
1 2 3 4 1 2 3 1 2 1   ->  1 2 3 4 7 9
4 4 4 4 4 4 4 4 4 4   ->  1
```
  
[Answer]
# [J](http://jsoftware.com/), 23 bytes
```
1+[:~.(i.~]{~#\|/i.@#)\
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DbWjrer0NDL16mKr65RjavQz9RyUNWP@a3KlJmfkK6QpGAKhEZw0BmGwlLo6RAVIzELBEGiiFR7VQIYtSBqhB1M5TM5IwRIma4SCTRQQSoyBPHNkhSABCI1iGMhWEyzwPwA "J – Try It Online")
We do the heavy lifting of creating the periods using integers, and then use those to index into our input. Specifically...
* `(...)\` For each prefix:
	+ `#\|/i.@#` Create a table of indexes to represent the possible periods. An example should make this clear:
	
	
	
	```
	  (#\|/i.@#) 1 1 2 3 1 1 2 3
	0 0 0 0 0 0 0 0
	0 1 0 1 0 1 0 1
	0 1 2 0 1 2 0 1
	0 1 2 3 0 1 2 3
	0 1 2 3 4 0 1 2
	0 1 2 3 4 5 0 1
	0 1 2 3 4 5 6 0
	0 1 2 3 4 5 6 7
	
	```
	+ `]{~` Pull these indexes from the input:
	
	
	
	```
	1 1 1 1 1 1 1 1
	1 1 1 1 1 1 1 1
	1 1 2 1 1 2 1 1
	1 1 2 3 1 1 2 3   <-- Input matches here, index 3.
	1 1 2 3 1 1 1 2
	1 1 2 3 1 1 1 1
	1 1 2 3 1 1 2 1
	1 1 2 3 1 1 2 3
	
	```
	+ `i.~` And find the index of the original input within this list. In this case, that index is `3`.
* `[:~.` De-dup.
* `1+` And add one.
# original approach, 24 bytes
```
[:~.1+i.&1@(-:"1#$&><\)\
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o63q9Ay1M/XUDB00dK2UDJVV1OxsYjRj/mtypSZn5CukKRgCoRGcNAZhiBSIY6FgCDTLCr8yW5A0Qg@mcpickYIlTNYIBZsoIJQYA3nmyApBAhAaxTCQrSZY4H8A "J – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-pae)
```
ṁƤi$ƤQ
```
A monadic Link accepting a list that yields a list of the unique period lengths.
**[Try it online!](https://tio.run/##y0rNyan8///hzsZjSzJVji0J/P8/2lBHAYiMUZEFGBkaxBKSBwA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##y0rNyan8///hzsZjSzJVji0J/H@4/VHTmqOTHu6cAaQj//@PjjaM5dKJNtRRACIjMAllQIWNkGTgpAlC0hjIgwkbo2g2ActgRzjshBlhHMsVCwA "Jelly – Try It Online").
### How?
```
ṁƤi$ƤQ - Link: list, A
    Ƥ  - for each prefix (p in A):
   $   -   last two links as a monad - f(p):
 Ƥ     -     for each prefix (x in p):
ṁ      -       mould like (p)
             -> Z = list of copies of x each "extended" to the length of p
  i    -     first 1-indexed index (of p in Z)
     Q - de-duplicate
```
[Answer]
# [R](https://www.r-project.org/), ~~88~~ ~~82~~ 81 bytes
```
unique(Map(function(i)Find(function(j)all(a[1:i]==a[1:j]),1:i),seq(a=a<-scan())))
```
[Try it online!](https://tio.run/##XU5NC8IwDL37KwJeEsjAzp1ku3rz5k12KLOTjlG7dsWB@Ntnhx9zBpLHy3v5cGMNeQJ1MFWvrwYHgjv4SppFlwZYw1H5XpsL3Jy0VrkxGN0FhQdp8WvUtNfmPPOGZNuiPImdLotiwqYkjozYqw5lIfNkuoYUY3ysgmm177FGQTSTCgULTvldoxWWYsq/mdH/cMpbzviFnxWzwymLUd1MLzwB "R – Try It Online")
Thanks to Giuseppe for fixing a mistake and -6 bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
¹Ƥṁ€ẹƊṂ$ƤQ
```
[Try it online!](https://tio.run/##y0rNyan8///QzmNLHu5sfNS05uGunce6Hu5sUjm2JPD///@GOgpGOgrGOgomOgpwNoRhCAA "Jelly – Try It Online")
## Explanation
```
¹Ƥṁ€ẹƊṂ$ƤQ  Main Link
[....].$    Group these two into one monad so Ƥ runs the whole link
            to its left
[][].Ɗ      Group these three into one monad so it accepts the link
            left argument as the right argument to ẹ instead of
            grouping ẹṂ into a dyad-monad monadic link
        Ƥ   For each prefix of the list: let it be the "sublist":
¹Ƥ          Map identity over prefixes; get all prefixes of the
            sublist
  ṁ€        Mold each prefix to the shape of the sublist; repeat
            elements until the two lists are the same length
    ẹ       Find all indices of the original sublist in the list
            of looped prefixes; essentially, find all prefixes
            that work for the period
      Ṃ     Take the minimum of these; this returns the period
         Q  Deduplicate; find only unique potential periods
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 69 bytes
```
a=>a.flatMap(x=>(j=1/a.some(v=>v-a[++j],j=i++)+j)>p?(p=j,i):[],i=p=0)
```
[Try it online!](https://tio.run/##bZDfboMgFIfvfYpzVwiKczZZtubQq13uCaxJidUOgkCUmL29w1m3dBuEP/m@3zkhaDnJsRmUD5l1l3bucJYoJO@MDG/Skw8URGORSz66viUTiimTFWO6TjUqxijTVPgj8ahTRV@qOlXo8YHOARDOSQH/jUwAFNE9QgHr/stFViabu0@svrxV/6z9XfXzly8jXc@tx3f3aJ5iag9/5/a@Mw@D6gnlozcqkN3J7ijv458YQAFmw5m44WnBU7yG5p3kpwvLr6uwi2CWUnpIAu/c8CpjglQqhbami2ycHZ1puXFX0hG1JOdP "JavaScript (Node.js) – Try It Online")
```
a=>a.flatMap(x=>                   // for i := 1 to a.length do
(j=1/a.some(v=>v-a[++j],j=i++)+j)  //   j := prefix size of repeating first i elements;
>p?(p=j,i):[]                      //   if j > p then p := j; add `i` to answer; endif;
,i=p=0)                            // endfor
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
```
ηε¼ηÅΔ¾∍Å?]>Ù
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3PZzWw/tObf9cOu5KYf2PeroPdxqH2t3eOb//9GGOgpAZAQm4QxjCBkLAA "05AB1E – Try It Online")
**Commented:**
```
η              # push all prefixes of the input
 ε        ]    # iterate over all prefixes:
  ¼            #   increment the counter variable
   ηÅΔ    ]    #   find the index of the first prefix of the prefix which satisifies:
      ¾∍       #     if extended to the length of the outer prefix (value of the counter variable)
        Å?     #     this is a prefix of the (implicit) input
               #     (and therefore equal to the outer prefix)
           >   # increment the 0-based indices
            Ù  # only keep unique ones
```
[Answer]
# JavaScript (ES6), 73 bytes
Returns a set.
```
a=>new Set(a.map((_,i)=>(g=m=>a.some((v,j)=>j<=i&&v^a[j%m])?g(-~m):m)``))
```
[Try it online!](https://tio.run/##dczNCoJAEAfwe0@xl2QG/EBXiKK1h@golout4uK6kmK3Xn0TSZG04c8wDPMbyXveZs@y6ZxaP4TJmeEsqsWLXEUH3FW8AbjbJbIICqZYxN1WKwHQ23LYyTMrLau/8VjuVYKXApy3wpPCNEU0ma5bXQm30gXkEPvkfyWIxPOIv/s1NhkSjP07rAyhGypYwLmHSxWQ47ajw@Ek6Pxg4ejw6LDW4ei2M2nzAQ "JavaScript (Node.js) – Try It Online")
### Commented
```
a =>                   // a[] = input array
new Set(               // build a set from the following array:
  a.map((_, i) =>      //   for each value at position i in a[]:
    ( g = m =>         //     g is a recursive function taking a modulo value m
      a.some((v, j) => //       check if there's some element in a[]:
        j <= i &&      //         that it is not located beyond the position i
        v ^ a[j % m]   //         and is not equal to the element at j modulo m
      ) ?              //       end of some(); if truthy:
        g(-~m)         //         recursive call with m + 1
      :                //       else:
        m              //         return m
    )``                //     initial call to g with m zero'ish
  )                    //   end of map()
)                      // end of Set()
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 15 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
┼↓Φ:'ñ╪⌐ñ∟M╕LbN
```
[Run and debug it](https://staxlang.xyz/#c=%7C%5B%7Bc%7C%5B%7Bn%25%3Amn%3D%7Dj%25mu%0AJ&i=%5B1%5D%0A%5B1,+1,+2,+1,+1,+2,+1%5D%0A%5B1,+2,+1,+2,+1,+2,+1,+2,+4%5D%0A%5B1,+2,+3,+4,+1,+2,+3,+1,+2,+1%5D%0A%5B4,+4,+4,+4,+4,+4,+4,+4,+4,+4%5D&m=2)
Output is as a string representing the codepoints of each period. Pretty printed with spaces for verification.
## Explanation
```
|[{c|[{n%:mn=}j%mu
|[                 prefixes of input
  {             m  map to
   c|[             dup and take prefixes
      {      }j    first element which satisfies:
       n%:m        when extended to current iteration length
           n=      equals the current iteration?
               %   take the length
                 u uniquify
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~18~~ 14 bytes
```
{a₀{ġz₁=ᵐ!}l}ᵘ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3wvzrxUVND9ZGFVY@aGm2BAoq1OUDxGf//R0cbxupEG@ooAJERmIQyIKJGSBJw0gQuZwzkwESNkbWagCWwo9hYAA "Brachylog – Try It Online")
*-4 because I remembered which zip I was using*
```
{           }ᵘ    Find every unique output from:
 a₀               for some prefix of the input,
    ġ             split it into groups of the same length except the last can be shorter
   {     !}       with that length being the smallest possible for which
     z₁           the non-cycling zip of the groups
       =ᵐ         contains only elements all elements of which are equal;
           l      output the length.
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 50 bytes
```
{∪{1⍳⍨⍵[⍴⍵]≡¨⍵}¨{L←⍴,⊃⌽⍵⋄L⍴¨⍵}¨{⍺,⍵}\¨{⍺,⍵}\⊂∘⍕¨⍵}
```
I'm fairly certain there's room for improvement, but it's just out of my reach, for the moment.
```
∪ ⍝ list unique values
 1⍳⍨ ⍝ get the index value of the first occurrence of 1 in the bit mask
   ⍵[⍴⍵]≡¨⍵ ⍝ create a bit mask by checking which padded strings match the last string in the expansion
     ¨ ⍝ for each list of padded strings
       L←⍴,⊃⌽⍵ ⍝ assign length of last string in expansion to L
          ⋄ ⍝ statement separator
            L⍴¨⍵ ⍝ for each string, reshape to length of longest string
               ¨ ⍝ for each list of strings
                 {⍺,⍵}\¨{⍺,⍵}\ ⍝ expand twice. (A, B, C) -> (A, AB, ABC) -> ((A), (A, AB), (A, AB, ABC))
                    ⊂∘⍕¨⍵ ⍝ for each element, encode as string and enclose
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqRx2rqg0f9W5@1LviUe/W6Ee9W4BU7KPOhYdA/NpDK6p9gMqAwjqPupof9ewFCj7qbvEBCsAVPOrdpQNixiCzH3U1PeqY8ah3KkQZ0DYFQy4gBkIjGAnmG6FgE6iYsYIJlIapNMGEILWGYGSEzAAKqycmqsOIJHVsXIiiJBBSBwA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 77 bytes
```
nub.map(\x->[p|p<-[1..],and.zipWith(==)x$drop p x]!!0).inits
import Data.List
```
[Try it online!](https://tio.run/##bY3PT4MwFMfv/BVvCckgoVXcEmNCOXnc3QPj8BiwvQjtC62RGP92sY5Ng9qmbfo@3x8ntM9N103UsxkcPKJDuSPrglbtJ/1SyR452o8iL/idM1GkUpYJ6lq@ET@RO0VKxWNYD4aBYSxXq9tYkiZnAyGWiVOPpFVtAoCIEhNnwjLq6EatxTrOwvzYuB3pxuOucVBgUpXKl8PQYC1fzVBbLyooOXfdgSm9kgfSLqyUagH996thSuG/JXKANEi9MYX5/sX8bBNc2VIx883F/XO2C/fDmW/8dH6vGd/pntx71Rb@7ovq49B2eLSTODB/Ag "Haskell – Try It Online")
Implicit function, taking a list of integers as input and returning a list of integers as output.
Not really satisfied with this answer, but I can't seem to avoid importing `Data.List`.
## How?
```
nub.                                -- remove duplicates from
map(\x->                            -- the list obtained replacing each x with
        [p|p<-[1..],                --     the integer p>=1
        and.zipWith(==)x$drop p x]  --     such that x is periodic of period p
    !!0).                           --   take the smallest such p
inits                               -- where x ranges over the prefixes of the input list
```
[Answer]
# [Python 2](https://docs.python.org/2/), 92 bytes
```
def f(l):r=[];p=i=1;exec"while l[p:i]!=l[:i-p]:p+=1\ni+=1;r+=[p][p in r:]\n"*len(l);return r
```
[Try it online!](https://tio.run/##dYzBCgIhGITvPYXtSVs7uHlSfBLXUyn7g9jPj0v19ObSITaIYWZgPhh81eVeptZuMbHEszDkfLDowCkbn/E6PBbIkWWPBsLRZW/gjMHg6NRcoKel0XkMHhkURibMZTjlWPqVpVhX6mNDglJ54l7JSV6klp/eUgUhDjuu/u5f6x3V8kcbbW8 "Python 2 – Try It Online")
This uses the fact that the periods of prefices are non-decreasing.
Ungolfed a bit:
```
def f(l):
 r=[];p=i=1
 for _ in l:                       # for each prefix of l (tracked by i)
  while l[p:i]!=l[:i-p]:p+=1       # find the next p s.t. removing a length p prefix or a length p suffix result in equal lists
  i+=1;r+=[p][p in r:]             # then add p to the return value if its not already there
 return r
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~19 17~~ 21 bytes
```
1+?{((#x)#',\x)?x}',\
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLszLUtq/W0FCu0FRW14mp0LSvqAXSXFxpCoZAaAQnjUGYK81B0QAsZaxgoWAIZDroGKIrBfONULAJVMxYwQRKw1SaYIEKAJkhG1s=)
Modeled after @Jonah's [J answer](https://codegolf.stackexchange.com/a/222912/98547).
* `{...}',\` for each prefix of the (implicit) input...
* `((#x)#',\x)` expand each prefix (of the current passed-in prefix) to the full length of that prefix (e.g., transform `1 1 2` from `(1;1 1;1 1 2)` into `(1 1 1;1 1 1;1 1 2)`)
* `(...)?x` get the index of the first transformed prefix that matches the prefix itself
* `1+?{...}` add one to the distinct indices
[Answer]
# Scala 3, 119 bytes
```
_.inits.toSeq.reverse.tail.map{a=>1.to(a.size).find(Seq.fill(a.size)(_)flatMap a.take zip a forall(_==_)).get}.distinct
```
[Try it in Scastie!](https://scastie.scala-lang.org/ERJ9KnBcTKKKxw9n3but7Q)
This is annoyingly long.
```
_                 //The input
  .inits          //Iterator of all prefixes (biggest to smallest)
  .toSeq          //Conver to Seq so we can do stuff to it
  .reverse        //Reverse so the smallest prefixes are first
  .tail           //Drop the first prefix, which is empty
  .map { a =>     //Map each prefix a to its possible period
    1.to(a.size)         //Range of possible possible periods
      .find(             //Find an i such that
        Seq.fill(a.size)(_)  //when you make a.size copies
          flatMap a.take     //of the first i elements of a
          zip a              //and zip those with a, dropping extra elements
          forall(_ == _)     //they all equal the corresponding elements in a
      ).get             //Unwrap the Option to get the possible period
  }.distinct      //Remove duplicates
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~110~~ 133 bytes
Sorry, got longer, fixed bug.
```
h v=l<$>(l v#v)
1#v=[1!v]
n#v=(n-1)#v++[[i!v|i<-[2..n],n!v==r n(i!v)]!!0|notElem(n!v)$r n<$>(n-1)#v]
r n=(n!).cycle
(!)=take
l=length
```
[Try it online!](https://tio.run/##bU7LqsIwEN3nKya0iwTHclO7NO7u0i8IWRQJt8HpKDYELvjvNVZEQRnmcc7MOczQT8dANM8DZEvbeqcIcpW1MFW2zsjsBZdJ8droKq9WzkWZr3G7dm3TsEeW2doLsCq09lL@XPmUfimMqmx0XTZ3z4faiwKLldTN4f9AQSipbeqPQZClwH9pmClOabIOBIAzHpeGLRpc6pP4QrX4nt2L3mCHj/523@FHfPFeNBvvxdhHtmN/3sP5EjlBDQXAAMu38w0 "Haskell – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 27 bytes
```
Ｗ⁻⊕Ｅθ⌕Ｅ⊕λ……θ⊕μ⊕λ…θ⊕λυ⊞υ⌊ιＩυ
```
[Try it online!](https://tio.run/##ZY69CsMwEIP3PoXHO3AHN2NGQ6FDIK9gXIMPzk7in5Q@vZvQoQkFDUL6BLLeJDsZbu3liZ2AgWLN8Ig2ueBicU8YzAyLFHeKX3/sGKXQb8tO@2mGn9v4IxYQzwEjnpbLf70DFVGMNXuoUmzHKNQAhNhfxkSxgDa5wMb0rSl129Wprl1X/gA "Charcoal – Try It Online") Link is to verbose version of code. Takes input by default as a character array, but it's also possible to feed it integer or string arrays by using JSON format. Explanation:
```
⊕Ｅθ⌕Ｅ⊕λ……θ⊕μ⊕λ…θ⊕λ
```
Loop over all prefixes of prefixes, extending them to the original prefix and finding indices of the first prefix where this results in the original prefix, then adjusting to give the periods.
```
Ｗ⁻...υ
```
While the list of periods contains a value not in the deduplicated list...
```
⊞υ⌊ι
```
... push the smallest missing value to the deduplicated list.
```
Ｉυ
```
Output the deduplicated list.
[Answer]
# [Haskell](https://www.haskell.org/), ~~96 95~~ 92 bytes
```
import Data.List
r=tail.inits
f=nub.map(\p->[length x|x<-r p,and$zipWith(==)p$cycle x]!!0).r
```
[Try it online!](https://tio.run/##bUxNa8JAEL3vrxjBg8IkuMlCKbiePOq5h3QpWxuboZvtstlCFP97uiSmanWGeQ/ex1S6@SqN6Tqq3bcPsNZBpxtqAvMyaDIpWQoN20v7857W2s1eXbIqTGk/QwXtqV0mHhxq@zE9knuhUM2knLvp7rAzJbRqMlnMU9/VmixIiP3tGzhPNkCxB3Myy6RgAAVX2BNmyLHHUXggZXh94iLnKHDgq7zAu1VKdRweTbIC4IxDBhwG/OdFLWejd5sY/Pzcvpy4aT/3fh7Vgccff9@j8xRTAu73nPoF "Haskell – Try It Online")
* saved 1 thanks to @Unrelated String
r=tail.inits
* all prefixes(excludes empty)
f=nub.map(\p-> ... ).r
* we map every prefix(.r`list`) by doing the job below and we return unique elements.
[length x|x<-r p, .. ]!!0
* list of prefixes of the current prefix being tested (x<-r p), which satisfy condition below.
We take the length and we return first element (shorter)
and$zipWith(==)p$cycle x
* True if difference of each elements of prefix and `possible period` is 0
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~79~~ 75 bytes
```
->x{(1..x.size).map{|i|(1..i).find{|j|i.times.all?{|k|x[k]==x[k%j]}}}.uniq}
```
Accepts an array (e.g. of strings or integers) and returns an array of ints.
Previous code:
```
->x{(1..x.size).map{|i|(1..i).find{|j|x[0...j].cycle.first(i)==x[0...i]}}.uniq}
```
[Try it online!](https://tio.run/##bVD9SoRAEP9/n2IQSoUcMA@iYO1BLglL5cbbW@1cwXJ9dhs9rax2mRn4fcHMuX15Hwv5NAZx13shYocNfeQ@ntK6t2QniHwsSGe9LS2hoVPeYKrUY2@PttsfEym5X5XJMAzYanobxhqKvRNCCLew9mgqB5takUmEMCCBFf@9IAYIxU/vL46xSGzTt3y0uL9rt3Hfz3zE6GWuGV/pzNyxagd//6JyeAXM09fDsyKdQ1aBVVYAkK5bcwNVa3jyjuqysecGsTvf1Lt@aMyZan8Vs2ieqxDciWKg4SPOTIJlRXpmQMolW@Q6E@Mn "Ruby – Try It Online")
[Answer]
# Java, 105 bytes
```
a->{var s=new java.util.TreeSet();int p=1,i=0;for(int c:a)s.add(p=a[i++%p]==c?p:a[0]==c?i-1:i);return s;}
```
[Try it online!](https://tio.run/##pY@xboMwEIb3PIWXSrYCViCZoE63bp3ohhiuYCJTYizbUEWIZ6eGEsTQpenpdD777v/0u4IO/Kr4HFX7UYsc5TUYg95ASNTvkIvl3Viw7ugaUaCrm@LEaiEvaYZAXwz52Z2ickDaWlHTspW5FY2kr0vzLKRNM2@zknB7RiUbwT/3HWhkmORfm/m75tztYBI7KVIs8AQ7xGWj8XTPIyCGQlFgxSAV@/2TyhjLX1QE6WHuhB9EgsSa21ZLZOJhvNuMV8PJzVh@pU1rqXJfsrXEJQWl6huezMye@2Ag5K8SL/QCb66PiJHLcK5L8xAk3HDWenoUdXTaO@T4D2OnmfN7rrRhN4zf)
]