[Question]
  [
Heavily based on [this closed challenge.](https://codegolf.stackexchange.com/q/148911/80214)
[Codidact post](https://codegolf.codidact.com/posts/279253), [Sandbox](https://codegolf.meta.stackexchange.com/a/20435/80214)
# Description
A Sumac sequence starts with two non-zero integers \$t\_1\$ and \$t\_2.\$
The next term, \$t\_3 = t\_1 - t\_2\$
More generally, \$t\_n = t\_{n-2} - t\_{n-1}\$
The sequence ends when \$t\_n ‚â§ 0\$. All values in the sequence must be positive.
# Challenge
Given two integers \$t\_1\$ and \$t\_2\$, compute the Sumac sequence, and output its length.
If there is a negative number in the input, remove everything after it, and compute the length.
You may take the input in any way (Array, two numbers, etc.)
# Test Cases
(Sequence is included for clarification)
```
[t1,t2]   Sequence          n
------------------------------
[120,71]  [120,71,49,22,27] 5
[101,42]  [101,42,59]       3
[500,499] [500,499,1,498]   4
[387,1]   [387,1,386]       3
[3,-128]  [3]               1
[-2,3]    []                0
[3,2]     [3,2,1,1]         4
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in each language wins.
  
[Answer]
## x86 machine code (8086), ~~15~~ 13 bytes
-2 bytes thanks to @EasyasPi.
```
00000000  31 C9 48 7C 07 40 41 29-D8 93 EB F6 C3            1.H|.@A).....
```
Callable function.
Expects `AX` = t1, `BX` = t2. Output is to `CX`.
Disassembly:
```
31C9          XOR     CX,CX    ; Set CX to 0
          LOP:
48            DEC     AX       ; --AX
7C07          JL      END      ; If AX < 0, jump to 'END'
40            INC     AX       ; ++AX
41            INC     CX       ; ++CX
29D8          SUB     AX,BX    ; AX -= BX
93            XCHG    BX,AX    ; Swap AX and BX
EBF6          JMP     LOP      ; Jump to tag 'LOP'
          END:
C3            RET              ; Return to caller
```
## Example run
Tested with DOS debug:
```
-r
AX=0078  BX=0047  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=0B17  ES=0B17  SS=0B17  CS=1000  IP=0000   NV UP EI PL NZ NA PO NC
1000:0000 31C9          XOR     CX,CX
-t
AX=0078  BX=0047  CX=0000  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=0B17  ES=0B17  SS=0B17  CS=1000  IP=0002   NV UP EI PL ZR NA PE NC
1000:0002 48            DEC     AX
...
-t
AX=FFFA  BX=0020  CX=0005  DX=0000  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=0B17  ES=0B17  SS=0B17  CS=1000  IP=000C   NV UP EI NG NZ NA PE CY
1000:000C C3            RET
```
```
[Answer]
# JavaScript (ES6), 24 bytes
```
f=(a,b)=>a>0&&1+f(b,a-b)
```
[Try it online!](https://tio.run/##dc5BDoIwEIXhvaeYFWljKzNtCbCAu7QIRkMoEeP1K7Wuqs7yffmTudmn3Yb7dX3IxZ/HEKaOWeF419sei4KOE3PCSsfD4JfNz@Np9he2r6RQAEBNnENZQnXIHSm6Ucl17hXG3rRtcpO7burYA/3pAbQASapJTl8u1bvXyfFnv9/nPxNe "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [convey](http://xn--wxa.land/convey/), 39 37 bytes
*-2 thanks to Jo King!*
```
{0(>>"!+?`}
,?"-v>^0^
^>>", 8~^
^<<<<
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoiezAoPj5cIiErP2B9XG4sP1wiLXY+XjBeXG5ePj5cIiwgOH5eXG5ePDw8PCIsInYiOjEsImkiOiIxMjAgNzEifQ==)
The Sumac Sequence gets calculated in the lower left part, with `{` taking the input and copying the sequence into `(` via `"` (copy):
```
{ (
,?"-v
^>>",
^<<<<
```
The sequence then gets converted to ‚Äì is it greater than 0 `0(`? Taking `!` that by itself, only 1s gets passed through into `+`:
```
0(>>"!+
    >^
```
There the accumulator loops around, waiting 8 steps `8~` so both the generating loop and the accumulator loop have the same speed. If there is an input waiting for `+`, `?` pushes the accumulator into `+`, otherwise ‚Äì if the sequence stopped thanks to a 0 ‚Äì it gets pushed into the output `}`.
```
 +?}
 0^
8~^
```
Everything put together:
[![71/120 run](https://i.stack.imgur.com/37n5l.gif)](https://i.stack.imgur.com/37n5l.gif)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
Œª-}(d1k
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3G7dWo0Uw@z//6MNDQx1TIxiAQ "05AB1E ‚Äì Try It Online") or [Try all cases!](https://tio.run/##S0oszvj/PzU5I19BN09B/dxu3VqNFMNsdQU7heT8lFS9xKRULq7yjMycVIWi1MQUhcw8rpR8LgUg0M8vKNHPL05MykyFUnAdCjY2NgoqYKV5qf//RxsaGeiYG8ZyRRsaGOqYGAEZpgYGOiaWlkCWsYW5DkjKWEfX0MgCyNA10jEG84HqAA)
**Commented**:
```
Œª }      # start a recursive environment:
         #   this produces an infinite sequence starting with input
 -       #   and calculates t_n according to t_n = t_{n-2} - t_{n-1}
   (     # negate every value
    d    # for every value: is it non-negative?
     1k  # find the first index of a 1 (smallest n such that -t_n >= 0)
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~16~~ ~~13~~ ~~12~~ ~~11~~ 9 bytes
Saved ~~1~~ ~~2~~ 4 bytes thanks to [Leo](https://codegolf.stackexchange.com/users/62393/leo)!
```
L‚Üë>0∆í¬∑:G-
```
[Try it online!](https://tio.run/##yygtzv7/3@dR20Q7g2OTDm23ctf9//@/ueF/QyMDAA "Husk ‚Äì Try It Online")
~~I wish it would parse the correct function without parentheses.~~ Leo found a 9-byte solution that doesn't use parentheses or even composition!
This my first time using `∆í` (`fix` from Haskell).
I'm told `fix` looks something like this:
```
fix :: (a -> a) -> a
fix f = let x = f x in x
```
Supposing the first argument (`¬≤`) is 120, and the second argument (`‚Å∞`) is 71, `f` (`o:¬≤G-‚Å∞`) would be something like `prevSequence -> 120 : scanl (-) 71 prevSequence`. So the `x` from above would become
```
x = 120 : scanl (-) 71 x
x = 120 : 71 : scanl (-) (120 - 71) (drop 1 x) //where drop 1 x is 71 : scanl (-) ...
x = 120 : 71 : 49 : scanl (-) (71 - 49) (drop 2 x)
...
```
and so on until it makes an infinite sequence.
Then `‚Üë>0` takes (`‚Üë`) while each element is positive, and `L` finds the length of that sequence.
[Answer]
# [sed -r 4.2.2](https://www.gnu.org/software/sed/), 44
* Thanks to @seshoumara for -2 bytes
```
:
s/^(1+) \1(1+)/\2 &/
t
s/1+ ?/1/g
s/.*-1//
```
[Try it online!](https://tio.run/##K05N@f/fiqtYP07DUFtTIcYQROnHGCmo6XOVAIUNtRXs9Q3104FMPS1dQ339//8NqQMUDAcI/MsvKMnMzyv@r1sEAA "sed 4.2.2 ‚Äì Try It Online")
### Explanation
The inputs are space-separated unary. Term 2 is given before term 1. E.g. (5, 3) would be `111 11111`; (5, -3) would be `-111 11111`.
* Line 1: loop label (unnamed - works in 4.2.2)
* Line 2: generate term n+2 by removing term n+1 from term n; Prefix term n+2 to the beginning of the pattern space
* Line 3: if the substitution on line 2 was successful, jump back to the loop label
* Line 4: Count the terms by replacing each term (followed by optional space) with 1
* Line 5: Handle negative inputs
* End of program: Implicit output of counter
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
L‚Üë>0¬°(‚Üí·∫ä`-
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8b/Po7aJdgaHFmo8apv0cFdXgu7///@jow2NDHTMDWN1og0NDHVMjIAMUwMDHRNLSyDL2MJcByRlrKNraGQBZOga6RiD@UaxsQA "Husk ‚Äì Try It Online")
...still haven't managed to get Razetime's (*edit: non-existant*) 9-byte answer (unless [zero-based indexing](https://tio.run/##yygtzv6f@6ip8X/Yo84lBocWajxqm/RwV1eC7v///6OjDY0MdMwNY3WiDQ0MdUyMgAxTAwMdE0tLIMvYwlwHJGWso2toZAFk6BrpGIP5RrGxAA) is Ok), but ~~I'm trying...~~ (*edit: I've now given-up*).  
*(Edit 2: ...but a 9-byte answer has now been [found](https://codegolf.stackexchange.com/a/218137/95126) by user & Leo!)*
**Commented code:**
```
L            # length of
 ‚Üë>0         # initial elements that are greater than zero of
    ¬°(       # infinite list by repeatedly appending list with
      ‚Üí      # last element of
       ·∫ä`-   # pairwise differences between elements of list so far
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~33~~ 24 bytes
```
ÔºÆŒ∏ÔºÆŒ∑Ôº∑‚Äπ‚Å∞Œ∏¬´‚äûœÖœâ‚â¶‚ÅªŒ∏Œ∑‚âß‚ÅªŒ∑Œ∏¬ªÔº©Ôº¨œÖ
```
[Try it online!](https://tio.run/##dc2xCsIwFIXhuX2KjPdChbaLQyfRpaClrxDbaxNoUkluVBCfPUbBSbr@8J0zKOmGRc4x9sErCIVo7TVwF8yZHCA2@WVxAo7kPZSFOGmrTTAQEFE882wNZXelZ1pxP5Ri8LDj1o70@ISOJskENWIh/nOVbJp@5b3TlmEvPcOBBkeGLNOYvuzE6nuBTYxVXYptFTe3@Q0 "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Edit: Saved 9 bytes when @Razetime pointed out I was using an inefficient algorithm. Explanation:
```
ÔºÆŒ∏ÔºÆŒ∑
```
Input the initial values.
```
Ôº∑‚Äπ‚Å∞Œ∏¬´
```
Repeat while the first value is positive.
```
‚äûœÖœâ
```
Keep count of the number of iterations.
```
‚â¶‚ÅªŒ∏Œ∑
```
Subtract the second number from the first number, storing the result in the second number.
```
‚âß‚ÅªŒ∑Œ∏
```
Subtract that result from the first number, resulting in the original second number.
```
¬ªÔº©Ôº¨œÖ
```
Finally print the number of iterations.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 25 bytes
```
f=->a,b{a>0?f[b,a-b]+1:0}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VY9BCsIwEEXX5hSzdyIzaUtbIfUgIUgKZicUmy6keBI3XeghxJN4G1Nriw6zmHn_M8y_3k5dfR6Gexe8LB5ey8ph3buKdt7U6GRt17yly6S_nuHQBtBgBMQyhhVhzhYhszgjYkxVRMmCMiJMyzKydGFJkSP_uRKUrIqIeEFSYdSBfjzqc0VYIcZXNkfX9GLVdKEFb_ZsyMZGmCa2FrQeF7biG2GO-gY)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `2`, ~~20~~ ~~8~~ 7 bytes
```
‚ÅΩ-·∏û¬±ƒãTh
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBMiIsIiIsIuKBvS3huJ7CscSLVGgiLCIiLCJbMTIwLDcxXVxuWzEwMSw0Ml1cbls1MDAsNDk5XVxuWzM4NywxXVxuWzMsLTEyOF1cblstMiwzXVxuWzMsMl0iXQ==)
Wow it's a been a while since I posted this, and a lot of things have been added/changed since.
## Explained
```
‚ÅΩ-d·∏û¬±ƒãTh
‚ÅΩ-d       # lambda x, y: x - y
   ·∏û      # Using the input as an initial vector, apply the above lambda infinitely, using all previously generated items as its stack
    ¬±ƒã    # Is the sign of each item not 1?
      Th  # First occurrence of 1
```
[Answer]
# TI-BASIC, 27 Bytes
```
While A>0
A-B->B
A-B->A
N+1->N
End
N
```
Takes t1 and t2 as input in A and B. Nothing fancy, the key is that when A is updated, B is the previous t1-t2, so the third line is able to recover t2 via t1-(t1-t2)->A without juggling a 3rd variable. There's a way to generate the sequence in 27 bytes as well with input as a list in Ans and dim( calls, but it proves too complex to trim out negative input and retrieve the true length of the sequence.
[Answer]
# [Raku](https://raku.org/), 20 bytes
*-4 bytes thanks to Jo King*
```
{+(|@_,*-*...^0>=*)}
```
[Try it online!](https://tio.run/##JclBCoMwFEXRrTxESo0m/PzYqmBCV9LgoBm1tOhI1LVHY2eHe3@v8X2PnxmXABuX8ro@fCWkUEo9yVlRbHEaZmS5h3VYAtbcbxnCd0SvmdBoVx0ijZqTbkSouy7RtA3OayA1t0mSYf6FXdwB "Perl 6 ‚Äì Try It Online")
The parenthesized expression is a list where the first terms are the two arguments to the function (`|@_`), successive terms are generated by subtracting the previous two terms (`* - *`), and the list stops just before the term (`...^`) for which zero is greater than or equal to it (`0 >= *`). Then the `+` operator converts that list to a number, its length.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 31 bytes
```
\d+
$*
+`(1+)¬∂\1$
$&¬∂$%`
\G1+¬∂?
```
[Try it online!](https://tio.run/##DcahDYUwFAVQf@coBOgj6X3lB1BIBsBWlAQEBkGYrQN0sX6OOs/5XvdeqmaLUsJhYTrY2NC2OQUamDonU0WElTanpRSqk5GgowyKn3MyzDP8NArhpadO6FX8d/0D "Retina 0.8.2 ‚Äì Try It Online") Takes the integers on separate lines but link includes test suite that splits on comma for convenience. Explanation:
```
\d+
$*
```
Convert to unary. Note that the signs are ignored at this stage, so that if the first number is negative, the next stage uselessly computes the sequence as if it was positive.
```
+`(1+)¬∂\1$
$&¬∂$%`
```
Compute additional terms until the last number is zero or greater than the absolute value of the previous number.
```
\G1+¬∂?
```
Count the number of leading positive terms.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 27 bytes
```
f(a,b){a=a>0?f(b,a-b)+1:0;}
```
This is the C equivalent of [Arnauld's JavaScript answer](https://codegolf.stackexchange.com/a/218113/100356)
[Try it online!](https://tio.run/##dY/BboMwDIbvPIXVCikRyZQEKtrRsgdhHAIhG1KXTpCeUJ6deV1VZZPmi@3fv5PPPX/r@3U7uv58NQMcZ2/Gy9N7vVqiWUcXfdK1eLGkY5p3NJPPogrr6Dx86NERCkuSAMa34ofZz03ZNqqFEw7gHotUgkEpA4skIRkUKpZ2Al3F4RBr@b5k8GsxZ8Cl2scSVwzyPx4VQvVDZi8TudEhk6gwHaHElGU0QnwUnxN6LdmkuYG0MMBrSM2r27D7db5tRBs1EhtL/ptRWt1eDsnjk2nw18khSRLWLw "C (gcc) ‚Äì Try It Online")
A and that's actually the work of [att](https://codegolf.stackexchange.com/users/81203/att). My function was initially 28 bytes and non-reusable.
[Answer]
# [Python 3](https://docs.python.org/3/), 29 bytes
```
f=lambda a,b:a>0and-~f(b,a-b)
```
[Try it online!](https://tio.run/##Vc7LCsIwEIXhtXmKWSYygVxaeoH4IuJiQg0WNC01Gze@eh0Fi87y4zD886NcpuzXNYUr3eJAQBh7OhjKg34mGZF0VGs53wsEkAL45NE6g409IdQKv2QsVo7Jb1Qbg1XXsVWb@bZB@7fyqK1rmexG2qFnMD8b9/kiFAiRpoUjIcKY4d3Vi928jLnIJPekIATg4Bc "Python 3 ‚Äì Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 46 bytes
```
param($a,$b)for(;$a-gt0;$i++){$a-=$b=$a-$b}+$i
```
[Try it online!](https://tio.run/##NYzRCoIwGIWv8yl@xl9s@A@2aajIwjeJCVqGpajQhfnsS9KuzvcdDqfv3tUw3qu29Vjb2fducE@OjrAUdTfwHJ28TSrHJgzFvIrF0q6B5RJi45cAp2qcRrBQ8OBQcG0UJVrQj5Wm2Gx8VoriLNskShPaNxFJbdKNpaHo3xoRiP37c5yB4RXkBZDzE9ZQXIV8dM2LERMMFv8F "PowerShell ‚Äì Try It Online")
[Answer]
# Python 3, ~~141~~ 125 bytes
```
def F(I):
 i=1
 if I[0]<0:
  return 0
 if I[1]<0:
  return 1
 while I[i-1]-I[i]>0:
  I.append(I[i-1]-I[i])
  i+=1
 return i+1
```
Thanks to @Razetime for pointing out the sequence itself didn't need to be returned.
[Answer]
# Prolog (SWI), ~~102~~ 93 bytes
```
d(A,B,C):-B<1,write(C);E is C+1,F is A-B,d(B,F,E).
:-read(A),(A<0,write(0);read(B),d(A,B,1)).
```
[Try it online!](https://tio.run/##LYxNCoAgFAb3naKljz4la1dtfFL3CJQQgsICj2@/u2FgZo/bui3ySCFnJwwYljrJg0aK4fTCUj@W4ShtpTE9YCTDCcaEkVTRyejnuyMIM9R/U1P/WiZ8S02kcm5V0agL "Prolog (SWI) ‚Äì Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 12 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
√¶`‚Äº->‚ñ≤](mœÉb=
```
Takes the two inputs in reversed order.
[Try it online.](https://tio.run/##y00syUjPz0n7///wsoRHDXt07R5N2xSrkXu@Ocn2/39zQwVDIwMuEyMFQwNDLhNLSwVTAwMuQwVjC3MuXUMjCwVjLmMFXSMuIwVjAA)
**Explanation:**
```
     ‚ñ≤        # Do-while true with pop,
√¶             # using the following four commands:
 `            #  Duplicate the top two values on the stack
  ‚Äº           #  Apply the following two commands separated on the current stack:
   -          #   Subtract the top two items from one another
    >         #   Check if the second top item is larger than the top item
      ]       # After the do-while, wrap everything on the stack into a list
       (      # Decrease each value by 1
        m     # Map over each value:
         œÉ    #  And take its sign: 1 if >0; 0 if ==0; -1 if <0
           =  # And then get the first 0-based index in this list of
          b   # value -1
              # (after which the entire stack joined together is output implicitly)
```
[Answer]
# [R](https://www.r-project.org/), ~~43~~ 37 bytes
*Edit: -6 bytes after peeking at [Arnauld's answer](https://codegolf.stackexchange.com/a/218113/95126): please upvote that one!*
```
f=function(a,b)`if`(a>0,1+f(b,a-b),0)
```
[Try it online!](https://tio.run/##Tc7RCoJAFATQd7/kXhph966hPtiPiOQqbS1sKqlgX7@RRfR2GAZmHnFe77Y/h8twXW5VdJVbh37x40AWHbfetWRPCvrgqINNO4biONtpCk8Kfl4o6UmLQq4ZbyqNTHYelUJWlrtNkeNTMEi1FDtTgflmwgnjt7zx/ynaat1gq6VhTuIL "R ‚Äì Try It Online")
[Answer]
## Batch, 65 bytes
```
@set/aa=%1-%2,b=%3+1,c=b-1
@if %1 gtr 0 %0 %2 %a% %b%
@echo %c%
```
`c` is provided so that the output is zero if the first parameter is negative, otherwise `@echo %3` would work. (On the first pass `%3` is the empty string, but `b=+1` still computes the correct value for `b`. `c=%3+0,b=c+1` would also work.)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~42~~ 35 bytes
Saved 7 bytes thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)!!!
```
n;f(a,b){for(n=0;a>0;++n)a-=b=a-b;}
```
[Try it online!](https://tio.run/##bZBha4MwEIa/@ysOQYg1Mo2WtmT2y9ivmDLSGDvZlhYTmKz41@euaqUtFXKJd8@by70y3EvZ95pXRNCdf6oODdFZxMU24kGgfRFmu0yEO971tbbwLWpNfOfkAH7nhFXGvtv4rYAMTjGLKMRRTGEZ4SlZrzBQCBluHb/TsFGzQjpFIN1sUItwzNaDil0pVHtU0qpylCyHejpEVGCndGLlh2gWGJX8VM0Iu3n7yvJ284Jr6VK4/k/cSYdTAzk3qnWpWpRFfDo@g6l/1aEilyf4T1NiMWc4BMFA@zAaMw8a41UXhwai4LcAmwH2EDBYr4jFKS3zb0sKS7Mv99pjg0hFXC8pKXhpCeEWvBI8k2v0YLyPgqGzVybLVDF16Jyu/5PVl9ibPvz5Bw "C (gcc) ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
R»ß_@R√ê¬ø@L
```
[Try it online!](https://tio.run/##y0rNyan8/z/oxPJ4h6DDEw7td/D5f3i5/qOmNZH//0cbGhnomBvG6kQbGhjqmBgBGaYGBjomlpZAlrGFuQ5IylhH19DIAsjQNdIxBlIGOgaxAA "Jelly ‚Äì Try It Online")
[As posted on Codidact](https://codegolf.codidact.com/posts/280307#answer-280307)
Takes \$t\_1\$ on the left and \$t\_2\$ on the right. [`R}»ß_@R√ê¬øL`](https://tio.run/##y0rNyan8/z@o9sTyeIegwxMO7ff5f3i5g/6jpjWR//9HGxoZ6JgbxupEGxoY6pgYARmmBgY6JpaWQJaxhbkOSMpYR9fQyALI0DXSMQZSBjoGsQA) works given the arguments in the opposite order.
```
R            Ascending range from 1 to t_1 (truthy if positive),
 »ß           and:
     √ê¬ø      collecting intermediate results, loop while
    R        positive
       @     on the reversed arguments:
  _          subtract
   @         the first from the second.
        L    Return the length of the conjunction.
```
`¬ø` and family, given a dyad, replace the right argument with the previous left argument on each successive iteration. This is incredibly bothersome for some tasks, but perfect for working with this exact kind of sequence.
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 25 bytes
```
f(a,b)=if(a>0,1+f(b,a-b))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728ILEoMz69YMGCpaUlaboWO9M0EnWSNG0zgbSdgY6hdppGkk6ibpKmJkT-ZmZiQUFOpUaigq6dQkFRZl4JkKkE4igpJCfm5Gik6SgkamrqKERHGxoZ6JgbxgKZhgaGOiZGIJapgYGOiaUliGlsYa4DljXW0TU0sgCxdI10jCEiRrGxUAthDgMA)
]