[Question]
  [
## Background
My user ID is 78410, or \$1 0 0 1 1 0 0 1 0 0 1 0 0 1 0 1 0\_2\$. One interesting property of this number is that, in binary,
* it doesn't have three consecutive identical digits, and yet
* it has a substring \$100100100\$ which is three copies of \$100\$.
So, I define a **Bubbler number** as a positive integer whose binary representation satisfies the following:
* it doesn't have three consecutive identical digits (so it is a member of [A063037](http://oeis.org/A063037)), and
* it contains a substring which is three consecutive copies of some nonempty string (so it is NOT a member of [A286262](http://oeis.org/A286262)).
## Task
Given a positive integer as input, determine if it is a Bubbler number.
You can use truthy/falsy values in your language or two distinct values to indicate true/false respectively.
There are 55 Bubbler numbers under 1000:
```
42 84 85 106 149 169 170 171 212 213 292 298 299 338 339 340 341 342 362 365
405 425 426 427 438 585 596 597 598 618 658 661 676 677 678 681 682 683 684 685
724 725 730 731 804 810 811 850 851 852 853 854 874 876 877
```
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply. The shortest code in bytes wins.
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 10 bytes
```
ḃsᶠ~j₃ˢlⁿ1
```
[Try it online!](https://tio.run/##Fc9NSkMxFAXgrZQ3Ppbc5N6bvIkuRBxU8Qd5ILRKkdJCLUiduQRxokMnijhxAa7iZSPP8wYfJzcJ4eR0Pju7uu9uLuOwWjaTg8NJszxa1ceP@rCr@7fmdn53Pm2mdf/eXMy6Bdfr/udp3X8@D/33btF/vWyuefXvtavbXxmGY40oimKQ4BBtIU45kCBKpITYMttCLVIqxNRAQhHJRwYNFEdOGcq7xretdcpU4EJGLvDslIlz4VwiJVIy5KjETIEEJbCqBOLamDYmf2CJeJZHThlsjwSFwcGJZQP7gY2V2wo1xDB@IZ38Aw "Brachylog – Try It Online")
This was meant to only be a partial solution, but it turns out that `ⁿ` fails on empty inputs.
```
  ᶠ           Find every
 s            substring of
ḃ             the input's binary digits,
      ˢ       then for each substring
   ~j₃        map it to the string which it is three copies of
      ˢ       (ignoring and discarding it if there is no such string).
        ⁿ     For none of those strings (of which there is at least one)
       l      is its length
         1    1.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~15~~ 12 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
bŒʒ3ä1ìË}{нË
```
Outputs `0` for truthy and `1` for falsey.
[Try it online](https://tio.run/##AR8A4P9vc2FiaWX//2LFksqSM8OkMcOsw4t9e9C9w4v//zQy) or [verify some more test cases](https://tio.run/##Fcw9CsJAEAXgq4TUr5iZ/XG3ykHEIgELKwtBCGJrk27PYOkVrBYbq5zBi6wvxccbHsw7X8bpdGzXeei736N0/TC36VO@xdWn1ldd7rf1XZeGtveG5JECVCLUZ2iknZDC1MjBMjMnynAuEdMLKRlc3HCDK1D@BQQeQlvGxDWjAGNn7ILI4Q8).
**Explanation:**
```
b         # Convert the (implicit) input to a binary-string
 Œ        # Take all substrings of the binary-string
  ʒ       # Filter it by:
   3ä     #  Split the substring into 3 equal-sized parts
     1ì   #  Prepend a 1 to each part
       Ë  #  Check that the three parts are equal
          #  (the prepend 1 is necessary, because ["01","01","1"] would be truthy,
          #   since strings and integers are interchangeable in 05AB1E)
  }{      # After the filter: sort all remaining substrings
          # (this causes any "000" and/or "111" to be leading)
    н     # Pop and push the first substring (or "" if none are left)
     Ë    # Check if all characters in this string are equal (also truthy for "")
          # (after which the result is output implicitly)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~64 63 61~~ 58 bytes
```
f=lambda n,i=2:[n>i>0<f(n,i+1),i>3][3*bin(i)[3:]in bin(n)]
```
[Try it online!](https://tio.run/##NdDNboMwDAfwO0/hI2wc8p1QDV4EcaAb2SK1KWJU6p6e@Z9uh/xkW46jeP3Zv25ZHUfsL/P1/DFTblOvTmMe0iDeYs3pq2zaNOhp1C/nlOvUjPo0pUxIcjMdy2Nd3nfqaTSqpWD42JakcIzpGAe8ALIlJRXQTIeoC4BbtA4AkRFAAm7RrsBDjQCq4IBncM3iSds54AHXnAQWOB7lvAMeoBZQCwpoYABP8coARFoA7gsCv5ICILWIbInwZasBWnzBAT9V1bZ83y9lNZnibaNMvLdtzp9LLYWQDaVIEUusqnVLeaf/Xfb0vPpXfibHLw "Python 2 – Try It Online")
A recursive function that returns `True` if the number is a Bubbler number, and `False` otherwise.
Generates all possible binary string, then for each binary string checks if `n` contains 3 consecutive copies of that string.
The binary strings are generated by evaluating `bin(i)[3:]` for \$i\$ from \$2\$ to \$n-1\$. The slice `[3:]` gets rid of the first 3 characters in the binary representation of \$i\$, which are always `0b1`. This allows us to generate binary strings that has leading 0.
[Answer]
# JavaScript (ES6), ~~54~~ 49 bytes
*Saved 5 bytes thanks to @l4m2!*
```
n=>/^(?!.*(.)\1\1).*(.+)\2\2/.test(n.toString(2))
```
[Try it online!](https://tio.run/##FcxBDsIgEEDRq@CqM1qnwJ4az@BS1JAKDQ2FBoiJp8e6@Xmrv5iPKVP2Wz3H9LbNqRbVODzhcqAjEGqhBf51Qi21HKjaUiFSTbeafZxBIrYpxZKCpZBmuBPRNWfzBcE5xwetZgN49cwjU@Necj5Um8EhLclH6HrW7Y8f "JavaScript (Node.js) – Try It Online")
### Regular expression
```
/^(?!.*(.)\1\1).*(.+)\2\2/
 ^                         // match the beginning of the string
  (?!         )            // must NOT be followed by:
       (.)                 //   a single character
     .*                    //   appearing anywhere
          \1\1             //   immediately followed by 2 copies of itself
                           // must also match:
                 (.+)      //   a string
               .*          //   appearing anywhere
                     \2\2  //   immediately followed by 2 copies of itself
```
---
# JavaScript (ES6), 55 bytes
This version uses a helper function to test `/(.+.)\1{2}/` and `/(.)\1{2}/` separately.
```
n=>(g=p=>n.toString(2).match(p+".)\\1{2}"))`(.+`&&!g`(`
```
[Try it online!](https://tio.run/##DctBDoIwEADAryAH2A24Ae5t4hs8irENQi0p26Y0Jsb49splbrPqt96naEM6s3/OeRGZhQQjgpBMyV9TtGxgQNp0ml4QmpJwHPvv8CsRFVCjqupkFKg8ed69m8l5AzciusSoP9B3XYf3YweAR1tYLIQ8pMW6NEdYkFZvGeq2qBHzHw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
BẆẋ3ẇɗƇ$ḢḊ
```
A monadic Link accepting a positive integer which yields a list - in Jelly an empty list (non-Bubbler) is falsey while a non-empty list is truthy (Bubbler).
**[Try it online!](https://tio.run/##y0rNyan8/9/p4a62h7u6jR/uaj85/Vi7ysMdix7u6Pr/qGGOU2lSUk5q0aOGuUBOXn6eLkLgcLv9///mFiaGBgA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##ASoA1f9qZWxsef//QuG6huG6izPhuofJl8aHJOG4ouG4iv8xMDAwUsOH4oKsVP8 "Jelly – Try It Online") (identifying all Bubbler numbers in \$[1..1000]\$).
### How?
```
BẆẋ3ẇɗƇ$ḢḊ - Link: positive integer, n
B          - convert n to binary (say b)
       $   - last two links as a monad - f(b):
 Ẇ         -   all sublists (say s) - Note these are sorted from shortest to longest
      Ƈ    -   filter keep those x of s which are truthy under:
     ɗ     -     last three links as a dyad - f(x, b):
   3       -       three
  ẋ        -       repeat (e.g. [1,0] -> [1,0,1,0,1,0])
    ẇ      -       is a sublist of (b)?
        Ḣ  - head (given an empty list this yields 0)
         Ḋ - dequeue
```
[Answer]
# [APL (Dyalog 18.0)](https://www.dyalog.com/), ~~34~~ 33 bytes
```
⊃1<∘⍸⊢{∨/⍺⍷⍨∊3/⊂1↓⍵}Ö(2∘⊥⍣¯1)¨2↓⍳
```
[Try it online!](https://tio.run/##PdC9SgNBEAfwPk8xZQJKdvb7wM7GVILxBQISm2AEKwk2Csd5sEERg62KcF0KCYrl5U3mRc7/pgjs7@b2ZnZ2byfXs8OL28lsftnJ8nV0KuWT6m1XCIu@pA0GSfobAAbtv2zuOqkf@EiqN0m/Un8spGqGu6ofSY1UtRlKfc9SvuTi7aqvc2n9JemzXfOgbfQu9d1NsZWkJbq1ayPlM04xPjvG8/xkNO4mVzfIW03RUnTEyhPbgthDUMCkWYMhXSAWEQoyJgKiVcCgyfjM9dDyIPdUjqzOPASyWOKwhSs8BIjkGRx4Jh88BMA8Yh41GLCwbxu0pYC2wShgigoHZwV4d4guR/yPM4BcyDyE3EIe3/N9VvW0bXA7rJT6Bw "APL (Dyalog Unicode) – Try It Online")
This uses `⎕IO←0` and the Over operator (`⍥`, which was added in 18.0). The current version on TIO is 17.1, so it's been implemented manually (thanks Bubbler!). I think this does well for a non-regex answer.
### Explanation
```
                              2↓⍳     ⍝ The range 2 to n-1
     ⊢               (2∘⊥⍣¯1)         ⍝ Convert this range and the input to base 2
      {∨/⍺⍷⍨∊3/⊂1↓⍵}Ö        ¨        ⍝ Before applying the function to each
                1↓⍵                   ⍝ Drop the first 1 of the binary number
           ∊3/⊂                      ⍝ Repeat the list 3 times and flatten
       ∨/⍺⍷⍨                          ⍝ Is this sublist in the binary input?
⊃   ⍸                                 ⍝ Is the index of the first element
 1<∘                                  ⍝ Greater than one?
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 46 bytes
```
{(*/0<3!+/+3':x)>*/^a?,/'3#','a:,/,\'|',\x}@2\
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLs6rW0NI3sDFW1NbXNla3qtC009KPS7TX0Vc3VlbXUU+00tHXiVGvUdeJqah1MIrh4jLUVktTN9RWtLS0BACy7A3c)
`2\` binary encode
`{` `}@` apply function
first condition:
* `,/,\'|',\x` all substrings of the argument, i.e. prefixes (`,\`), reverse each (`|'`), prefixes each (`,\'`), raze (`,/`)
* `a:` assign to `a`
* `,/'3#','` triplicate each, i.e. enlist each (`,'`), 3-reshape each (`3#'`), raze each (`,/'`)
* `a?` find - indices in `a`, or nulls (`0N`) for not found
* `^` is null?
* `*/` all
second condition:
* `3':` sliding window of size 3
* `+` transpose
* `+/` sum
* `3!` mod 3
* `0<` positive?
* `*/` all
`>` and not (between the two conditions)
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Unix utilities, 44 bytes
```
dc -e2o?n|egrep -v 000\|111|egrep '(.+)\1\1'
```
[Try it online!](https://tio.run/##S0oszvj/PyVZQTfVKN8@ryY1vSi1QEG3TMHAwCCmxtDQECqirqGnrRljGGOo/v@/iTEA "Bash – Try It Online")
Input is on stdin, and the output is the exit code (0 for truthy, 1 for falsey, as usual with shell scripts).
Or [verify the Bubbler numbers under 1000](https://tio.run/##NY7LCoMwEEX3@YpLKagEH@lWa1fttj/gxibRCDqRVKUL/z0V0c0wc7nnMJ/6a7ysJ5Sjs62rBxTF5fl@XbySiPXNPmjVrdMj4gVZllWrEOJIgjDhUSUqEfiNYEyawSrM/IfDxRrrEIZ0FzkVYqNz4jyKGKDsNoCugZbG4kpYkaTnCyVSpZeU5r7fa8BkNB0rTmS/m263kfZ/).
[Answer]
# perl -M5.010 -n, 45 bytes
```
$_=sprintf"%b",$_;say!/(.)\1\1/&&!!/(.+)\1\1/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3ra4oCgzryRNSTVJSUcl3ro4sVJRX0NPM8YwxlBfTU0RxNGG8P7/N@Qy4jLmMjHisjDhsjDlsjDjsjDnMrcwMTT4l19QkpmfV/xf19dUz8DQ4L9uHgA "Perl 5 – Try It Online")
Turns the input into a string with the binary representation of the number, applies regexes to test the requirements, then prints 1 or an empty string accordingly. Two bytes (the `!!`) could be saved if there wasn't a restriction for two distinct values -- without them, for bubbly numbers, it prints the thrice repeated string.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
tṠḟ·€*3Qḋ
```
Returns a list, which is nonempty iff the input is a Bubbler number. In Husk, empty lists are falsy and nonempty lists are truthy.
[Try it online!](https://tio.run/##AR8A4P9odXNr//904bmg4bifwrfigqwqM1HhuIv///8xNjIz "Husk – Try It Online")
## Explanation
```
tṠḟ·€*3Qḋ   Implicit input: a number, say n=84.
        ḋ   Binary representation: [1,0,1,0,1,0,0]
       Q    Sublists: [[1],[0],[1,0], …, [1,0,1,0,1,0,0]]
  ḟ         Find the first one that satisfies this (or an empty list if none do):
              Example list: [1,0]
     *3       Repeat three times: [1,0,1,0,1,0]
 Ṡ ·€         It occurs in the list of sublists: yes.
            Result: [1,0]
t           Remove the first element: [0], truthy.
```
The correctness of this program relies on the fact that `Q` enumerates the sublists in a "good" order (all sub-sublists of a sublist occur in the result before the sublist itself) and `ḟ` returns the first match it finds.
If 000 occurs in the binary representation, then [0] is listed before any longer triply repeated sublist (unless that sublist consists of only 1s, in which case [1] is listed before it).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ ~~13~~ ~~12~~ ~~11~~ 10 bytes
```
BẆẋ3eɗƇ`ḢṖ
```
[Try it online!](https://tio.run/##Fc89TgMxEMXxC73CHzNju@UWdDRpUC5AS5FI0ENPzQFIWqRIOYa5iPlb8k9vZ71avXk@HI8vaz3M62le3@vh/nk7P82fr3n5WL/neTlxbm9/r9@Pa1lRN3VXTqFsQznQErJKLqgqgxwdQ7V2kJaQUVRjc1lC2QJNxrfOv30EGroiwxFZ0QINzJ25F1QYXK0YyJqQ1RNVcwLPTvpONvAK7toWaKK9qkyuEBNlE/1EY@O1yVwl7RXqPw "Jelly – Try It Online")
*The third -1 takes some inspiration from Kevin Cruijssen's 05AB1E solution.*
*Fourth -1 thanks to Jonathan Allan reminding me of Jelly's truthiness semantics.*
Outputs truthy or falsy.
```
 Ẇ            Every substring of
B             the input's binary digits.
      Ƈ       Filter them by
  ẋ3 ɗ        repeated three times
    e         membership in
BẆ     `      every substring of the input's binary digits.
         Ṗ    Is there more than one element to remove from
        Ḣ     the first (i.e., shortest) of the filtered substrings?
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 44 bytes
```
.+
$*
+`(1+)\1
$+0
01
1
A`000|111
1`(.+)\1\1
```
[Try it online!](https://tio.run/##Fck7DoAgFETRftaBCUpC3vANpZWboMDCwsbCWLp3xO6e3Pt4zmvvk95atwZqgWmaZq6EMgIhiLWJyEuObtr@r7J3FxAcmApYElzw8MM@RcTkEUtGLvED "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
.+
$*
```
Convert to unary
```
+`(1+)\1
$+0
01
1
```
Convert to binary.
```
A`000|111
```
Delete the string if it contains `000` or `111` (`A`(.)\1\1` also works for the same byte count).
```
1`(.+)\1\1
```
Check whether there are three consecutive substrings.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 28 bytes
```
≔⍘Ｎ²θ¿⬤01¬№θ×ι³⊙θΦκ№θ×³✂θλ⊕κ
```
[Try it online!](https://tio.run/##XYzBCsIwEETvfsXiaQMRWiso9FQFoZci1B@oca1L09QmW8Gvj61HB@Yyb3jm2XgzNDbGIgRuHR6bQLV4di2W7jVJNfU38qg0bOeOKl/xA7CwFtdJutZQDYKnYXKCo4Yr9xSQNWRqCVxmj2DhPgs8s5XZ1Gn4@2caasuGlsVqKJ3x1JMTumP386g8xv1hlyZx87Zf "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for true, nothing for false. Explanation:
```
≔⍘Ｎ²θ
```
Input the number and convert it to base 2 as a string.
```
¿⬤01¬№θ×ι³
```
Test whether neither digit `0` nor `1` appears triplicated in the string.
```
⊙θΦκ№θ×³✂θλ⊕κ
```
Check whether any nontrivial substring appears triplicated. (I use `Φ` instead of a second `⊙` since Charcoal doesn't currently accept an implicit range there, but the effect is the same.)
[Answer]
# T-SQL, 258 bytes
Added some line changes to make it readable
```
DECLARE @ char(99)=''
WHILE @i>0
SELECT @=left(@i%2,1)+@,@i/=2;
WITH C as(SELECT number+1n FROM spt_values WHERE'P'=type)
SELECT count(*)FROM C,C D
WHERE not(@ like'%000%'or @ like'%111%'or len(@)<D.n*3+C.n+2)
and @ like'%'+replicate(substring(@,C.n,D.n+1),3)+'%'
```
Returns 1 or more for true, 0 for false
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1244668/bubbler-numbers)**
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~124~~ ~~120~~ ~~114~~ 113 bytes
```
b,c,i,j;f(a){for(b=c=1;a;a/=2)for(b&=a&7^7&&a&7,i=~3,j=1;++j<11;i*=2)c&=~i&(a>>j^a|a>>j*2^a)||!(a>>j*3-1);b&=!c;}
```
[Try it online!](https://tio.run/##VY3LbsMgEEX3/gqSKggMaU2yiBSM@yOVJQx1O1ZqR3lUSLHz6@5A2kVnMVc6OnPHrT@cm5@gd4erfyfl@eJheP6ssn/oAE1kGfQX8mWhZ98DeE5uGcGJ0A1X3IYUOqF2OLGIAyKlMUqiiqLQRIjwd5Y8Fvjr8YRqy5Yrvycr/9YvJQnyt1GY5PD942N41E/ZNDfSSZCdbpnlt/ivMc4obbV9MRueADWW7uodpRgSzH0rOzSE6EqlNOSoOWruQJmtqq62Y4x8U1s@jovE8u1acY09C6enef4B "C (gcc) – Try It Online")
~~-4~~ -5 bytes: ceilingcat
[Answer]
# [Raku](http://raku.org/), 37 bytes
```
{.base(2)~~/(.+)$0$0/&none /(.)$0$0/}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Wi8psThVw0izrk5fQ09bU8VAxUBfLS8/L1UByIdwa/8XJ1YqpBelFgD16CgY6ukZGhgY/AcA "Perl 6 – Try It Online")
This matches the base-2 representation of the input number against the junction
```
/(.+)$0$0/ & none /(.)$0$0/
```
...which succeeds if it matches the first pattern, but not the second one.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 11 bytes
```
bṅÞS'3/≈;h≈
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJi4bmFw55TJzMv4omIO2jiiYgiLCIiLCI3MjUiXQ==) or [get all the Bubbler numbers up to a given number](https://vyxal.pythonanywhere.com/#WyIiLCInIiwiYuG5hcOeUyczL+KJiDto4omIIiwiwqwiLCIyMDAiXQ==).
Port of Kevin Cruijssen's 05AB1E answer. Outputs \$0\$ for truthy and \$1\$ for falsy.
#### Explanation
```
bṅÞS'3/≈;h≈   # Implicit input
bṅ            # Input as a binary string
  ÞS          # All substrings
    '   ;     # Filtered by:
     3/       #  Split into three parts
       ≈      #  All equal?
         h    # First item
          ≈   # All equal?
              # Implicit output
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
```
->n{n.to_s(2)=~/^(?!.*(.)\1\1).*(.+)\2\2/}
```
[Try it online!](https://tio.run/##Hc/PTsMwDAbw@57C3BroMuefnR4KD7IOJNB2mgpauwPaxqsXfz3kpy@WYyuX6@fvcuqX7et4G/38/TE10fV/u/fm7ck/N94NYQgO6cUNcYi7x/JznSdq2HsfmNn56Xg@fs10o/t4p9N@PNCD@p72G6IcW6rZTmkpsBi5MwQog9BSDBEko0PqKrCWlCpAygwCsJYkK6XFCrbZOa4IUAMPC5aWToACq0kABYgNExWgALWKWo0ggQzWLRotK7ZoYmCdlfGzwADXglTWhG@XBNCiKwJ0c1j@AQ "Ruby – Try It Online")
### How it works:
```
->n{
  n.to_s(2)      # convert to binary representation string
  =~ /           # check if it matches regex
  ^(?!.*(.)\1\1) # (from the start) assert that there are no 3
                 # repeated characters anywhere in the string
  .*             # skip any number of characters
  (.+)\2\2/      # check that there is a sequence of 1 or more
                 # characters repeated 3 times (note that there
                 # are no 3 repetitions of a single character so
                 # the 1 case is irrelevant (equivalent to ..+))
}
```
*squints eyes*  
"regex..."
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 74 bytes
```
($s=[Convert]::ToString("$args",2))-notmatch'(.)\1\1'*($s-match'(.+)\1\1')
```
[Try it online!](https://tio.run/##TdFdT8IwFAbga/YrGjKFyUbafbQbCQkJ8Voj3AEhOMuHAYZrpybIb8fzThEv9uT0zelp2h2KD12atd5ug7wo9dld9o/ntmv6k2Gxf9elnfV642Jky81@1W66i3Jlmn7oecG@sLuFzdetdtebiqlo3dGu4BJ1fjLvfHIc15aVHi6MNqzPBu049Fka05f4THBJxBkhgeJA@CwUIYiIDFWWAmqJohSgijkQgFoiWUNDYw7CGgkUgW0JjkwyCRSgTAqQAEmjpJJAAWQpsjQEEYgBTVFhDFBFHFBfynErwQGWCaqkrnDlJAJoUTUS0EEqjQX3HId3u4LzTr30M6XC7OuGHZ2GW2pTbS293a27ZO6cEv150LnVL5S5cxZs9uz6xk5j8jgaVsYWu4fnV2qbDWhIY1TluTb4A5d5gX5jf5OoY6yN7dfzG0@XE397Kbr/d@R108k5Oedv "PowerShell Core – Try It Online")
]