text:
Jimmy needs a new pair of shoes!
Jimmy has had a busy last week with all these platforms and ropes, and poor Jimmy doesn't even have legs or feet to stand on!

Your job is to take a string containing multiple Jimmys and give them legs and shoes!
Get input in the form of a Jimmy String
Jimmy String => /o\  /o\   /o\
containing only /o\ and
give each Jimmy in the input a pair of feet that look like this:
 /o\
_/ \_

Turn the inputed floating head Jimmy string into Jimmy with feet string, like so:
// Input

       /o\   /o\          /o\

// Output

       /o\   /o\          /o\
      _/ \_ _/ \_        _/ \_

If 2 Jimmys are close together they must move over to make room,
Jimmys will always move towards the right to make room for other Jimmys.
// Input

/o\/o\

// Output

 /o\  /o\
_/ \__/ \_

Other Jimmys that are further away must not be moved unless necessary
// Input

/o\/o\      /o\

// Output

 /o\  /o\   /o\
_/ \__/ \_ _/ \_

// Input

/o\/o\    /o\

// Output

 /o\  /o\  /o\
_/ \__/ \__/ \_

Standard rules and loopholes apply,
This is code-golf, so may the shortest answer win.

Suggested test case: /o\<sp>/o\<sp><sp><sp><sp><sp><sp><sp><sp>/o\/o\, my current implementation fails because it moves the last two Jimmies towards the left instead of right.. All of your test cases succeed, though.

Python 2, 131 120 115 114 121 118 bytes
o=1;W=[]
for g in map(len,input().split('/o\\')):W+=[' '*(g-o)];o=max(o-g,0)+2
for q in' /o\ ','_/ \_':print q.join(W)

Try it online!
4 bytes thx to movatica; 10 bytes lost for bug fix.

o+=2-len(g) saves you a byte

118 bytes

@movatica: there was a bug, but it was offset by your edits :).

Charcoal, 28 bytes
 Ｆ⌕Ａθ/«Ｊ∧ι⊖ι¹ＷＫＫ→Ｐ_/ \_Ｍ↗/o\

Try it online! Link is to verbose version of code. Explanation:

Print a space to defeat Charcoal's automatic left margin.
Ｆ⌕Ａθ/«

Loop over all of the left arms.
Ｊ∧ι⊖ι¹

Jump to the desired left foot location. Note that Charcoal has no problem drawing at (-1, 1), but the question does not allow that, so we have to take care to avoid drawing at negative positions.
ＷＫＫ→

Move past any existing output.
Ｐ_/ \_Ｍ↗/o\

Output the feet and then move to output the Jimmy.

Ruby -p, 77 75 bytes
The "don't move Jimmy if not needed" rule was quite an ordeal to work around but I think it worked out quite well. Shorter than Python by quite a bit (at time of writing), at least.
-2 bytes from recursive.
r=/(\\ ?|^)(\S+) ?/
gsub(r){"#$1 #$2"}while~r
puts$_
gsub(/ .o. ?/,'_/ \_')

Try it online!

Could you use \S+ in place of \/\S*?

PowerShell, 96 bytes
($o=$args-split'/o.'|%{' '*($w=($l+=$_.Length-1)*($l-gt0));$l-=$w+1})-join' /o\ '
$o-join'_/ \_'

Try it online!
Unrolled:
$o=$args-split'/o.'|%{
    $len += $_.Length-1
    $width = $len*($len-gt0)    # len or 0, if len < 0
    ' '*$width
    $len -= $width+1
}
# $o is array of space strings now
$o-join' /o\ '
$o-join'_/ \_'

Python 2, 152 148 140 bytes
o=[-4]
for i,c in enumerate(input()):o+=[max(i,o[-1]+5)]*('/'==c)
for s in' /o\ ','_/ \_':print''.join('%*s'%(b-a,s)for a,b in zip(o,o[1:]))

Try it online!

Retina, 40 37 bytes
\+`(^|\S.)(/\S*) ?
$1 $2
 /o. ?
_/ \_

Try it online!
Thanks to Value Ink for golfing off 3 bytes.

Enjoy your new shoes!

Well, tried to pretend these challenges don't exists for a while. (No relation to that Jimmy.)

I believe the pattern match I used in my Ruby answer (\\ ?|^)(/\S*) ? is shorter than the one in your first line and should give the same results (probably; I don't know Retina at all)

Stax, 29 28 24 25 bytes
¢▄▌ß╙EVäN»0►,δñï◙,Θ╙BÅhΓ?

Run and debug it
There was a bug in the 24 byte solution that caused some off-by-1 errors in some cases.

JavaScript (ES6), 107 bytes
s=>` /o\\
_/ \\_`.replace(/.*/g,j=>s.split(/.o./).map(s=>s.slice(n,l=s.length,n=n>l?n-l+2:2),n=1).join(j))

Try it online!

MATLAB, 111 bytes
Try it online
function J(s)
s=[' ' s];s=replace(s,{'\/','\ /'},'\  /');for k=find(s=='o')
o(k-2:k+2)='_/ \_';end
char(s,o)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Cops: The Hidden OEIS Substring
This is a Cops and Robbers challenge. This is the cop's thread. The robber's thread is here.
As a cop, you must pick any sequence from the OEIS, and write a program p that prints the first integer from that sequence. You must also find some string s. If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence. s + s + s in the same location will print the fourth, and so on and so forth. Here's an example:

Python 3, sequence A000027
print(1)

The hidden string is two bytes.

The string is +1, because the program print(1+1) will print the second integer in A000027, the program print(1+1+1) will print the third integer, etc.
Cops must reveal the sequence, the original program p, and the length of the hidden string s. Robbers crack a submission by finding any string up to that length and the location to insert it to create the sequence. The string does not need to match the intended solution to be a valid crack, nor does the location it's inserted at.
Rules

Your solution must work for any number in the sequence, or at least until a reasonable limit where it fails do to memory restrictions, integer/stack overflow, etc.

The winning robber is the user who cracks the most submissions, with the tiebreaker being who reached that number of cracks first.

The winning cop is the cop with the shortest string s that isn't cracked. Tiebreaker is the shortest p. If there are no uncracked submissions, the cop who had a solution uncracked for longest wins.

To be declared safe, your solution must stay uncracked for 1 week and then have the hidden string (and location to insert it) revealed.

s may not be nested, it must concatenated end to end. For example, if s was 10, each iteration would go 10, 1010, 101010, 10101010... rather than 10, 1100, 111000, 11110000...

It is acceptable to start on the second term of the sequence rather than the first.

If your sequence has a finite number of terms, going past the last term is allowed to result in undefined behavior.

All cryptographic solutions (for example, checking the hash of the substring) are banned.

If s contains any non-ASCII characters, you must also specify the encoding being used.

For anyone attempting to find a good sequence, the OEIS has a webcam that selects random sequences.

If I claim "the hidden string has length 10 or less", my answer is not cracked, and my hidden string actually has length 8, what is my score? Or is it simply not allowed to claim a larger length than your actual length?

@LuisMendo I would probably say that claiming a larger length than your actual length is not allowed. Is there any reason you'd want to? That would probably just make it easier for robbers.

@DJMcMayhem Probably no reason, other than cause confusion. But I agree it's better not to allow that. (The claimed length in my answer exactly corresponds to my hidden string)

MATL, sequence A005206. Cracked by SamYonnou
voOdoO

Try it online!
The hidden string has 8 bytes.

voodoo??? I'm convinced MATL is black magic now

Cracked

Python 2, sequence A138147 (cracked)
print 10

Try it online!
The hidden string is 7 bytes. The sequence goes:
10, 1100, 111000, 11110000, 1111100000, ...

Cracked.

Since the challenge specifies that any string up to the given length can be used to crack, this can also be done relatively trivially with just a 2 byte string

@Theo how? As I understand it, the string needs to be inserted repeatedly end to end, not nested

@DreamConspiracy oh you're probably right, I took "If you insert s into the same location in p" to mean that you could nest them.

Keg, sequence A000045
0.

The hidden string is ≤6 bytes(in order to conform the updated cracking rules)

Correct, the rules say any string up to that length.

No TIO for Keg :-(

Assuming no unicode characters are used, there is no such string of length ≤3. (I looped over all of them.) I used master^, since master crashes on your initial program. So you either need to explain how to run your interpreter correctly, or fix it. :P

If I should not just revert the last commit (as I did), what version should I revert to?

My program was invalid. I rewrote my program.

Cracked.

@LuisMendo not yet at least

@tomsmeding what exactly do you mean by crashing?

@Jono2906 You can ask Dennis to include it. But better wait a few days, based on the comments in the chat room

@Jono2906 $ python3 Keg.py examples/cat.keg produces IndexError: list index out of range; before commit 34d4d87, the interpreter seemed to work.

@tomsmeding fixed.

Cracked
Brain-Flak, sequence A000290 (Square numbers)
((()))({}<>)

Try it online!
The hidden string is 6 bytes.
Fun fact:
I "discovered" this property while playing this brain-flak based game.  The hidden string was a randomly generated item that I discovered was very useful.

Cracked.

Pyret, sequence A083420, Cracked
fold({(b,e):(2 * b) + 1},1,[list: ])

The hidden string has 4 bytes or fewer.

Cracked. You're new here; welcome to Code Golf SE! How are you liking it so far?

Nice! Thanks, I’m learning as I go!

V, sequence A000290. Cracked by Cows quack
é*Ø.

Try it online!
The hidden string is 5 bytes.

This doesn't print the first term of the sequence A000290 which is 0...

@ExpiredData Hmm. I could easily edit my answer to start at 0 without affecting the byte count, but there are several other answers that start on the second term too. I don't really want to invalidate those

Cracked in 4

Java 8+, sequence A010686 (cracked by xnor)
Lambda function.
()->System.out.println(1);

The hidden string is ≤ 5 bytes

Cracked?

That is indeed one of the 2 possible strings I came up with @xnor. The other was ^2<<1 but that's the same thing.

Python 3, sequence A096582
This is really trivial, as I haven't tried Cops and Robbers challenges before.
print(100)

The hidden string is 3 bytes.

cracked

Python 3, sequence A014092 - (cracked)
from sympy import isprime, primerange
from itertools import count
r=1
print(r)

Try it online!
The hidden sequence is 82 bytes.
My intended code (which doesn't rely on the Goldbach Conjecture) was:
i=(n for n in count(2)if all(not isprime(n-x) for x in primerange(1,n)))
r=next(i)
#

Cracked by NieDzejkob, who uses the Goldbach Conjecture to solve it in a magical 42 characters. Great job!

Did you assume the Goldbach conjecture?

Cracked

Forth (gforth), A000042 - (cracked)
1 .

Try it online!
The hidden sequence is 5 bytes, and it can easily handle hundreds of terms.
A one-byte solution that breaks due to integer overflow is also possible. In fact, I'd say it is embarrassingly trivial. While the challenge text, under some interpretations, might allow you to call that a crack, I urge you not to.

Cracked. I liked this one.

Desktop Calculator, sequence A006125
1n

The hidden string ≤ 12 bytes.

Cracked.

Haskell, sequence A083318 (cracked)
f=length[2]

Try it online!
The hidden string is 5 bytes. The sequence goes:
1, 3, 5, 9, 17, 33, 65, 129, 257, 513, ...

Nice one! Cracked

Brain-Flak, sequence A000984 (central binomial coefficients)
(())({{}}{})

Try it online!
The hidden string has 36 bytes or fewer.

Cracked.

Python 3, A268575
from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Try it online!
The hidden sequence is 102 bytes.

Cracked by Liresol

@Liresol has cracked your answer.

AsciiDots, 36 bytes, A019523
/>1#*$_#\
*^-{+})./
|/\/\/\
\/\/\/\&

Try it online!
The hidden string has 12 bytes.

Cracked

Haskell, A000045 (Fibonacci) -- Cracked
f = head [0, 1]

I've got a solution with a whopping 23 bytes. I don't expect this to be safe for long, but it was super fun to come up with.
Solution:

 I thought Haskell would be a fun language to try this challenge with -- the natural thing is to do to end up adding a function call every time, but if the sequence can't be written recursively in terms of the last term only, you run into some trickiness with Haskell's strictness and function application.
 Khuldraeseth na'Barya found a super clever way to do this with an applicative functor. I did something much less brilliant, using where-hacking:

f = head [b,a+b]where[a,b]=[0,1]
          ^^^^^^^^^^^^^^^^^^

 (This is actually 18 bytes. My less-golfed 23 byte version, where I'd totally forgot about pattern matching, used [last a,sum a]where a= instead.)

Cracked. Welcome back!

VDM-SL, sequence A000312
let m={1|->{0}}in hd reverse[x**x|x in set m(1)&x<card m(1)]

The hidden string has 33 bytes or fewer

That VDM-SL link doesn't seem to work.

@nichartley it's a link to the language manual as a PDF.. so maybe you're viewing it on something that can't view PDFs

This works.

This doesn't quite seem to be a full program... and I haven't actually figured out how to turn it into one yet. Obviously it's assigning a lambda to m, but I can't tell how to actually call it

...except it's not, because the in is already there, so it's not even a function, just an expression? A REPL snippet? At least I've figured out how to run it...

@unrelatedstring yes it's an expression, you could also run it by having a function that takes no parameters and returns a seq of nat

Cracked

...unless this is supposed to print the first n numbers in the sequence for n string repetitions? That's not my understanding of the rules

I don't mind at all (and already deleted my robbers post)

@UnrelatedString I've added a binding to the set comprehension which should force you to use the 35 byte plan I initially had, also the hd reverse should make it pop the last element. I noticed 2 bytes I could golf from the string so it's now 33. GL if you're still trying!

That should be fun, thanks

I've found a disappointingly trivial 13-byte crack, but I think I'll at least try to find the intended solution before posting it.

Now I'm trying to use composition, but 1) it's killing Overture because maps are supposed to be finite and 2) the string I've arrived at (which ended up just causing an internal error) is way longer than 33. So now I'm really getting curious as to why m is a map

13 bytes :o I'm not very good at this challenge then haha. In VDM you can define consecutive let statements for the same variable and reference the previous one my solution used that if that clue helps. M is a map just to make things more confusing @unrelatedstring

The 13 bytes are let x=x+1 in , bypassing the generate-first-n-terms yet again. I actually avoided doing that to m, under the assumption that you had not considered that possibility. I'll post the trivial crack now, but I'll keep working on the intended solution, because the closest I've gotten to it is currently at 43 bytes.

Cracked
cQuents, sequence A003617
=1#2:pZ

Try it online!
The hidden string is 1 byte.

Cracked

Brain-Flak, sequence A000578 (Cube numbers)
((())<>)

Try it online!
The hidden string is 16 bytes

cracked

Java 8+, 1044 bytes, sequence A008008 (Safe)
class c{long[]u={1,4,11,21,35,52,74,102,136,172,212,257,306,354,400,445,488,529,563,587,595,592,584,575,558,530,482,421,354,292,232,164,85,0,-85,-164,-232,-292,-354,-421,-482,-530,-558,-575,-584,-592,-595,-587,-563,-529,-488,-445,-400,-354,-306,-257,-212,-172,-136,-102,-74,-52,-35,-21,-11,-4,-1},v={0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,-1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,-1,0,0,0,0,0,0,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1},w={1,0,0,-1,5};long d=1,e=1;void f(long a,long b){long[]U=u,V=v,W,X;while(a-->0){U=g(U);w=h(v,w);}W=h(v,U);while(b-->0){V=g(V);v=h(v,v);}X=h(V,u);if(w[0]!=v[0]){int i,j,k=0;u=new long[i=(i=W.length)>(j=X.length)?i:j];for(;k<i;k++)u[k]=(k<i?W[k]:0)-(k<j?X[k]:0);d*=e++;}}long[]g(long[]y){int s=y.length,i=1;long[]Y=new long[s-1];for(;i<s;){Y[i-1]=y[i]*i++;}return Y;}long[]h(long[]x,long[]y){int q=x.length,r=y.length,i=0,j;long[]z=new long[q+r-1];for(;i<q;i++)if(x[i]!=0)for(j=0;j<r;)z[i+j]+=x[i]*y[j++];return z;}c(){f(3,0);System.out.println(u[0]/d);}public static void main(String[]args){new c();}}

Try it online!
Can be solved using a hidden string of size 12. Can definitely be golfed more, but there is no way this is actually winning. I just wanted to contribute out of respect for the number 8008.
Note: before anyone complains that the sequence is hard-coded, I've tested this up to the first term that diverges from the hard-coding (13th term = 307) and it gets it correctly albeit slowly. This is also why it's using long instead of int, otherwise it overflows before that term.
Update (Jul 12 2019): updated to be a bit more performant. Computes the 13th term in 30 seconds on my computer now instead of 5 minutes.
Update (Jul 17 2019): fixed bugs in for loop bounds for the g function, and array length bounds in the bottom of the f function. These bugs should have eventually caused problems, but not early enough to get caught by just checking the output. In either case, since the presence of these bugs 5 days into the game might have confused some people enough into being unable to solve this puzzle, I am totally fine with extending the "safe" deadline until July 24th for this submission.
Update (Jul 18 2019): After some testing I have confirmed that overflows start after the 4th term in the sequence and start affecting the validity of the output after the 19th term. Also in the program as it is written here, each consecutive term takes roughly 5 times longer than the previous to compute. The 15th term takes about 14 minutes on my computer. So actually computing the 19th term using the program as written would take over 6 days.
Also, here is the code with sane spacing/indentation so it is a bit easier to read if people don't have an IDE with auto-formatting on hand.
class c {

  long[] u = {1, 4, 11, 21, 35, 52, 74, 102, 136, 172, 212, 257, 306, 354, 400, 445, 488, 529, 563, 587, 595, 592, 584,
      575, 558, 530, 482, 421, 354, 292, 232, 164, 85, 0, -85, -164, -232, -292, -354, -421, -482, -530, -558, -575,
      -584, -592, -595, -587, -563, -529, -488, -445, -400, -354, -306, -257, -212, -172, -136, -102, -74, -52, -35,
      -21, -11, -4, -1},
      v = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0,
          0, 1, 0, 1, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
      w = {1, 0, 0, -1, 5};

  long d = 1, e = 1;

  void f(long a, long b) {
    long[] U = u, V = v, W, X;
    while (a-- > 0) {
      U = g(U);
      w = h(v, w);
    }
    W = h(v, U);
    while (b-- > 0) {
      V = g(V);
      v = h(v, v);
    }
    X = h(V, u);
    if (w[0] != v[0]) {
      int i, j, k = 0;
      u = new long[i = (i = W.length) > (j = X.length) ? i : j];
      for (; k < i; k++)
        u[k] = (k < i ? W[k] : 0) - (k < j ? X[k] : 0);
      d *= e++;
    }
  }

  long[] g(long[] y) {
    int s = y.length, i = 1;
    long[] Y = new long[s - 1];
    for (; i < s;) {
      Y[i - 1] = y[i] * i++;
    }
    return Y;
  }

  long[] h(long[] x, long[] y) {
    int q = x.length, r = y.length, i = 0, j;
    long[] z = new long[q + r - 1];
    for (; i < q; i++)
      if (x[i] != 0)
        for (j = 0; j < r;)
          z[i + j] += x[i] * y[j++];
    return z;
  }

  c() {
    f(3, 0);
    System.out.println(u[0] / d);
  }

  public static void main(String[] args) {
    new c();
  }
}

Solution

 f(1,v[0]=1); right before the System.out.println
 The program works by computing the n'th Taylor expansion coefficient at 0. Where the original function is a quotient of polynomials, represented by u and v which I got from here, except that in the linked document the denominator is not multiplied out, and nowhere do they say that you have to compute the Taylor series, I stumbled on that by accident and then confirmed via another source.
 The calculation is done via repeated application of the quotient rule for derivatives.
 The incorrect first term of v, the entire array w and a few other things like the function f having any arguments are thrown in to mess with people.

I guess your submission is the first uncracked one!

Added a solution

You should probably also edit the header to say that it's safe

MATL, sequence A000796. Cracked by SamYonnou
'pi'td1_&:_1)Y$J)

Try it online!
The hidden string has 3 bytes.

Cracked

Unefunge-98 (PyFunge), sequence A000108
1.@

Try it online!
The hidden sequence is 19 bytes.

Cracked.

Haskell, sequence A014675, cracked by nimi
main=print$uncurry(!!)([2],0)

Try it online!
The hidden sequence is 35 bytes.
Here's my intended solution:

 main=print$uncurry(!!)$((l:n)->(l>>=flip take[2,1],n+1))([2],0)
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

My guess.

Python 3, A008574, cracked by xnor
print(1)

Try it online!
Insert 4 bytes to complete A008574. A008574: a(0)=1, thereafter a(n) = 4n.

Cracked.

@xnor so fast... T_T

Brachylog, 7 bytes (Brachylog SBCS), A114018 (Cracked)
≜ṗ↔ṗb&w

Crack it online!
The string has 2 or fewer bytes.

 Fatalize's solution, ẹb, is the original string which I had intended. Note that ẹk also works, for the same reasons. In addition to the issue with 9001 beheading to 001=1, it actually turns out that b on a number just won't fail, because all single digit numbers behead to 0, including 0 itself.

That apparently useless b is fairly suspicious…

Cracked

C# (.NET Core), A003678, 29727 bytes (Safe)
using System;using System.Linq;using System.CodeDom.Compiler;class P{static void Main(){Int32 z=0;\u0049nt32 T(\u0049nt32 i){i--;var \u0064="";for(;i>0;\u0069/=5)d=i%5+d;return d.Aggre\u0067a\u0074e(0,(a,b)=>a*5+b%48*2%5)+1;}System.D\u0069agn\u006fs\u0074ics.Pro\u0063ess.\u0053tart(CodeDo\u006dProvi\u0064er.\u0043reateP\u0072ovider("CSharp").Co\u006dpi\u006ceAssembly\u0046romSource(new Com\u0070ile\u0072P\u0061ra\u006det\u0065rs(new[]{"System.dll"}){GenerateExecutable=true,\u0047enerateI\u006e\u004de\u006dor\u0079=false,Out\u0070utAs\u0073\u0065m\u0062\u006cy="One.exe"},Stri\u006eg.Con\u0063at(@"5FKX4&4A@6W]4V0).7K]073W:J7`1G?V4H;T1*'V.VD).7K]073W:J7`1G?V4H;T1*'V.VD)8F'[4FOX3V/_.:0&?FK]:I?_2FL*?G?X?X\+1&8T:IDU0746;&\+?FTA3XL&3XL=B'L:8T\V*W3V5X[TB'L:8T[Y?6/T1*T-8X?A?6P_5H@:*ET&/ZT-8X?>)W3X4X0C.7DU2(\&3XL&9G0&*W3V5X[T1*T-8X?A*60I?G;V1FPU?V06:Z,S?X`C.7DU2(\_5H@:*J0&B'L:8T\V9G0=3T`'/WPA/6D_5H@:*DWVA&W^/U`_5H@:*DPV3Z+_?JT-8X??*67[4(0B/V;W:Y#P5*+_:G0&B'L:8TL=B'L:8TL=B'L:8TL=3XKB4&0.:F'[?60KB'L:8T[>4J#VB'L:8TT;=&0*0ZT-8X?A0J'a<J,)/T`B=(`G@V0*5FT'A&W^/T`'/WPA/6DTB'L:8T[>A*T-8X??.&OV@V/Y/VSV4*/V7W?`1V/[0H/H4*T-8X??*4L;;)#b.70&9HL=B'L:8T\V9H<J?FTU4F0_5H@:*$WV2&L9+:(T7W3V5X[T1*T-8X?A*60J?JT-8X??9*,_5H@:*J'V4V/_B'L:8TW@/Z0&?FTU4ZT-8X?A.*T-8X?A0G3U56O_B'L:8T[>B'L:8TS=1F7[4(0*26OV1&<6,:T-8X?A/W?=9)$G:WHB;)#P3ZT-8X?A?XL=B'L:8TL=3XL9+7@*B'L:8TT;0:$_5H@:*$P_5H@:*$WV1D`6=&0)?&/_+:T-8X??*7?_B'L:8T[OB'L:8T\;5G?V1I#=.70_5H@:*J0=9HL&9H<_5H@:)TL*?G?V4JT-8X?A)W4*1H;D?:T-8X?A*:T-8X?>9*,_5H@:*F/W/X0'/WPA/6DT/ZT-8X?>)G@U4V0)/W4*A:Ka4&0.:F'[?6/T1'4T07?X1'4X4Z,*/ZT-8X?A?60'4X0'/WPA/6DT/ZT-8X?@9*T-8X?A.'4_5H@:*HL_5H@:*(C`=6OV2*,*1*T-8X??9&,,1VSV1FKXB'L:8T[Y4(0'/WPA/6DT/U'_0*T-8X??)ZT-8X?A?60'4Z?V0JT-8X?A)VSVB'L:8T[VB'L:8T[=B'L:8T[>/GG^2&/]1F7[4(0B58`C<&(_5H@:*F<T/ZT-8X?@9&8'B'L:8T\=B'L:8TT;B'L:8TSO=6OV2*,*B'L:8T[Y2*D_5H@:*%S^/X<H/ZT-8X??)FL_5H@:)TWZ?G4G4&0.:JT-8X?@)FDT/ZT-8X?>8VSX4F8*07CV/GG^2&/]1JT-8X?A.&D'7XLC;)4'/WPA/6DTB'L:8T[>=&0*0VDT@V0_5H@:*$X-2*T-8X?A/Z8*?JT-8X??*60)/W4_5H@:*$X64&0.:F'[?60J2&8)07?X5&/U56O_/ZT-8X??)FKX1'468Y$C;)4'/WPA/6DT/YLU2*T-8X?A.*,SB'L:8T\V/U_VB'L:8T[=B'L:8T\VB'L:8T\=B'L:8TT;?G?X1'4X4Z,_5H@:*$WV4F0_5H@:*F0_5H@:*$X64VW^/VCY7ZT-8X?@.'4*)HDC<(`U:Y4'/WPA/6DT/Y?_07;X4V8+/ZT-8X?@)ZT-8X??-6O_/VL_5H@:*$KX1*T-8X?A/X0:;)$G4&0.:F'[?:T-8X?A)U8_5H@:*$WV2*,*06D'@:T-8X??*:T-8X?A9G?V4F0_5H@:*F0*7W3V5X[T1*(_5H@:*DPM?FSX?J$&/U_V?W0U2*,*06D'@7@UB'L:8TS@/ZT-8X?A?60'B'L:8TS@7W?`1V/[0H/H4*T-8X??*4L;;)4B4X`G4&0.:F'[?:T-8X?A)Y?_07<_5H@:*ET*07CVB'L:8TW>56O_B'L:8T[>1FKX1'469I$C<'3V5X[T1*'V.F8'B'L:8T\=2&X_5H@:*6;^/VTU4ZT-8X?A0FT_5H@:*4P,B'L:8TT:2&/]1F8_5H@:*F<'7W3V5X[T1*'VB'L:8TOA?JT-8X??9&8_5H@:*HL_5H@:*HD&/Z?V0F/_/W4V/V,,1VSV1FKX1'46:W@B;)3T1*T-8X?A*6/QB'L:8T[O4*+_2:T-8X?@0FOV2*,*1&T_5H@:)TW`1V09<:T-8X?A)VL_5H@:*$L[B'L:8T[L?G4LB'L:8TT;B'L:8TW>17L_5H@:*HL&<'3V5X[T1*'V=J,_5H@:*(CX?J$&/Z@_5H@:*DOY/VSV4*/VB'L:8TW>56O_/VK]0:T-8X?A0G46:WHB;)$G4&0.:F'[?60_5H@:*8K]1JT-8X?A.&4_5H@:*F0XB'L:8TS@?G?V4F0'4X0'/WPA/6DT/YLUB'L:8TT;0:,SB'L:8T\V/Z?V0F/_/W4V/V,,1VT_5H@:*DP_5H@:*$K]06D'7X`*:Y$G4&0.:F'[B'L:8T[@/ZT-8X?@9&8'?FS`=6P_5H@:*DO_?JT-8X??*6C_B'L:8TW>B'L:8TSL1VSV1JT-8X??)F8_5H@:*F<'7W3V5X[T1*T-8X?A*60M?FT_5H@:*ETU?'/VB'L:8TP;B'L:8T[>0F0_5H@:*(CV4*/V/GG^B'L:8TT;/ZT-8X??)FKX1'46:W@B;)4_5H@:*4K[?6/Q074U2*T-8X??.)G^/VTUB'L:8TS@1*T-8X??9*C`1V09B'L:8TX=B'L:8T[@?94'/WPA/6DT/Y@_5H@:*(CX4F8*07CV/GG^B'L:8TT;/VK]06D'7XLC;)$G4&0.:F'[?6/T1*T-8X?A/Z'X4V8_5H@:*F<'@7@U4V0)B'L:8T[>4'@64&0.:F'[?6/QB'L:8T[O4*T-8X?A9FT_5H@:*%TLB'L:8TT:/ZT-8X??9*,*1&SU56O_/ZT-8X??)FKX1'464&0.:F(_5H@:*F<T/U[XB'L:8T[VB'L:8T\=2&XLB'L:8TT:/VTU4VC_B'L:8TW>56O_/VK]06D'7W3V5X[T1*'VB'L:8TX;074U2*T-8X??.)H_5H@:*(@_5H@:*DO_?G@_5H@:*F;_/GG^2&0_5H@:*$K]0:T-8X?A0G464&0.:F(_5H@:*F<T/YD_5H@:*DP_5H@:*$WZB'L:8T[Y?58'B'L:8TSA1'7V/JT-8X??-6P_5H@:*(CV1FL_5H@:*ES[4(0'/WPA/:T-8X?A0J'VB'L:8TXT/W?Z1*T-8X?A*:T-8X?>9&/Y/VSV4*/V/GH_5H@:*(?_B'L:8T[>1FKXB'L:8T[Y4(0'/WPA/6DT/ZC`B'L:8TT:/Z?V0F/_/W4VB'L:8T[>/GG^2&/]1JT-8X?A.*T-8X?A0G46:Z7`1G?V4H<K?G?Z:Y$G:Y7[0(`C<'3V5X[T1*'V+6SWB'L:8TS>4F0'4Z@_5H@:*DOY/VT_5H@:*DP'?ZT-8X?A)V,,1VSVB'L:8TS=B'L:8TS=06D'7X`*:Y$G4&0.:F'[?60J2*T-8X?A.'<_5H@:*ET*07CV/GH_5H@:*(?_B'L:8T[>B'L:8TS=1F8_5H@:*F<'7TLC;)3T1*'V.F8'?FS`B'L:8TWY1V0_5H@:*(DU4VC_A&W^/X<K1*T-8X?A*7L_5H@:*J0-1I4'/WPA/6DT/Y@_5H@:*(D_5H@:*ET)0:T-8X??*68+/ZT-8X?@)ZT-8X??-6O_B'L:8T[>B'L:8TS=B'L:8TS=0:T-8X?A0G469I$C<*T-8X?@)JT-8X?A0JT-8X?A*6/Q074U2&XL1V/_B'L:8T\=B'L:8TS@1&T[26OV8JT-8X?@.*'V4'@_5H@:*ET*B'L:8TSO/FH-B'L:8T\=3V8*B'L:8TSO<'3V5X[TB'L:8T[Y?60J2&8)07?XB'L:8TSAB'L:8T[>/GG^B'L:8TT;/ZT-8X??)FKX1'468Y$C<&'[?60_5H@:*8CX4*+_29G^/ZT-8X??9*,*1&T[26P_5H@:*DP9.JT-8X?A0FD&/ZT-8X?A9JT-8X?A/U('?94'/WPAB'L:8TW=1*'V.JT-8X?A.'4U2&X_5H@:*6;^/VT_5H@:*HL*B'L:8T[YB'L:8TT;/JT-8X??-6O_/ZT-8X??)JT-8X??)F8_5H@:*F<'7W3V5X[T1*'V.JT-8X?A.'4_5H@:*HL_5H@:*(C`=:T-8X??8V/_?G@_5H@:*F;_/GG^2&/]1F7[4(0'/WPA/6DT/ZT-8X?>*JT-8X?A9FSX?J$&/Z@_5H@:*DOY/VSVB'L:8T[V?V/UB'L:8TSL1VSV1FKX1*T-8X?A/X0B58`C<&(_5H@:*F<T/U\_5H@:*ET'B'L:8T\=2*T-8X??.)G^/VTU4ZT-8X?A0FT_5H@:)TX_5H@:*%S^/X<KB'L:8T[Y?7L_5H@:*J0_5H@:*$O]<'3V5X[T1*'V=J,_5H@:*(D_5H@:*ETU?'/V@V/YB'L:8T[>2&0'?V/U56O_/VK]06D'7X`*:Y$C<*T-8X?@)FDT/U[X4*,_5H@:*(C`=6OV2*,*1&T_5H@:)TW`B'L:8TT:/X;HB'L:8T[@/W4_5H@:*$X_5H@:*ET_5H@:*$W`/JT-8X??9JT-8X??)ZT-8X?A9G/XB'L:8TS@294'/WPAB'L:8TW=1*'V<VSX4F8*0:T-8X??*JT-8X?A)V,,1ZT-8X??9&/]1F7[B'L:8T[V7X@C;)$G4&0.:F'[?6/D1FL_5H@:*ESW4*8_5H@:*$XU4V0)B'L:8T[>4'@64&0.:F'[?:T-8X?A)ZT-8X?>*J+_0:,S3V0_5H@:)XCV0JT-8X?A)VSVB'L:8T[VB'L:8T[=/V,,1VSV1FKX1'46:Z,B;)4'/WPA/:T-8X?A0J'V=J+_0:,S3V0Z/V;V2&0'?V0_5H@:*4P,1VT_5H@:*DO]1F7[4(0B4X`C;)$C<'3V5X\_5H@:*4K[?60M?JT-8X??9*T-8X?A.*T-8X?A9JT-8X?A9'/V.ZT-8X?A)Z0&?JT-8X??9*,*0:T-8X?A0JT-8X?A/Z8*?G?V4F0'B'L:8TS@7W?`1V/[0H/H4'?=9)$G:Z(U1H`G4&0.:F'[?:T-8X?A)YLU2&8U?'/V@V0_5H@:*D[V2&0_5H@:*F0V/V,,1VSV1FKXB'L:8T[Y4(0B58`C;)4'/WPA/:T-8X?A0J'VB'L:8TWOB'L:8TS@/VTU4ZT-8X?A.*T-8X?A0G4X4Z,*B'L:8T[>4F0'B'L:8TS@7W3V5X\_5H@:*4K[?60_5H@:*8K]1JT-8X?A.&4_5H@:*F0X4Z,*/W;V4'@64&0.:F'[?60M?FSX?J$&/ZT-8X?>9&/YB'L:8T[>2&0'?ZT-8X?A)V,,1ZT-8X??9&/]1JT-8X?A.&D'7X`T?FLB;)4'/WPAB'L:8TW=1*T-8X?A*60M?FT_5H@:*ETU?'/V@V0_5H@:*D\_5H@:*DO_B'L:8T[>4*/VB'L:8TW>56P_5H@:*(D_5H@:*DO]1F7[4(0B?:+]:Y$C<'3V5X[T1*T-8X?A*60_5H@:*8D_5H@:*ET'B'L:8T\=2&XLB'L:8TT:/ZT-8X??9*,_5H@:*$W[2&,,1VSV1JT-8X??)JT-8X?A.&D'7W3V5X[T1*'VB'L:8TX;0:T-8X?A/Z+_B'L:8TSOB'L:8TWYB'L:8TT:B'L:8T[>2*,*1*T-8X??9&,,1VSV1FKX1'464&0.:F'[?:T-8X?A)YLU2&8U?'/VB'L:8TP;/V;V2&0'B'L:8T[=/V,,1VSV1FKXB'L:8T[Y4(0B?:+]:Y$G/6DT/U[X4*+_29G^B'L:8T[>2*,*1*T-8X??9*C`1ZT-8X?A)X<K1*(_5H@:*$P&5FLG4&0.:F'[?60J2&8)07?X5&/U56P_5H@:*(CV1JT-8X??)F7[4(/=;)$G/6D_5H@:*DWV.F8'?FS`=:T-8X??8V/_B'L:8T\=4VC_A&W^/X;H?:T-8X?A)ZT-8X?A/W?X4ZT-8X??.&+\5J,&07?`<'3V5X[TB'L:8T[YB'L:8T[@B'L:8T[><VSX4JT-8X?A.'?XB'L:8TSAB'L:8T[>/GG^2&/]1JT-8X?A.&D'7X@C;)4'/WPA/6DT/ZT-8X?@9FK]B'L:8T[O0'4X4Z,*/W;V4'@64&0.:F(_5H@:*F<T/ZT-8X?>*J+_0:,_5H@:*HD&/Z@_5H@:*DOY/VSVB'L:8T[V?V/U56O_/VK]0:T-8X?A0G46:Z(U1H`C<'3V5X[T1*'V.F8'?FS`=6OV2*,_5H@:*$W[2&,_5H@:*%G^2&/]B'L:8TS=06D'7W3V5X[TB'L:8T[Y?:T-8X?A)YLUB'L:8TT;0:,S3V0Z/V;V2*T-8X?A)W4_5H@:*DKV/GG^2&/]1F8_5H@:*F<'7X`T?FLB;)3T1*(_5H@:*DOQ074U2&XL1V/_B'L:8T\=4VC_B'L:8TO@2:T-8X??8V09.V8+B'L:8T[O?60G4&0.:F'[?:T-8X?A)Y?_07;X4ZT-8X?A.'CV/GG^B'L:8TT;B'L:8T[>1FKX1'46)I$C;)$G4&0.:F'[B'L:8T[@/YLU2&8U?*T-8X?A?V/R/Z0&?FTUB'L:8TS@06D'@7@U4V0)/ZT-8X?A/W@64VW^/VCY7U8'4TL;;)4B?8`G4&0.:F'[?60J2&8)07?X5&/U56O_/VL_5H@:*$KX1'468Y$C<'3V5X[T1*T-8X?A*60MB'L:8T\=2&8_5H@:*HLS3V/R/Z0_5H@:*J0_5H@:*HK_B'L:8T\=4ZT-8X?A.*T-8X?A0JT-8X?A/Z8*B'L:8T\=4V0_5H@:*J'V4'@64VW^/VCY7U8'4TL;;)4B48`G4&0.:F(_5H@:*F<T/ZT-8X?>*J+_0:,S3V0Z/V;V2&0'?V/U5:T-8X??8VSV1JT-8X??)F7[4(0B?:+]:Y$C<'3V5X[T1*'VB'L:8TOA?FSX?J$&/U_V?W0UB'L:8TT;?JT-8X??*:T-8X?A.&D'@:T-8X??*:,_5H@:*$WV4JT-8X?A)W4*7W?`1V/[0H0_5H@:)TL*2&8'B'L:8T[?;)4B1X`G4&0.:F'[?60_5H@:)X?_07;X4V8+B'L:8T[>B'L:8TW>5:T-8X??8VSV1FL_5H@:*ES[4(0B:Y$C<'3V5X\_5H@:*4L_5H@:*F<TB'L:8T[>,7?V2*,*B'L:8T[O1'4_5H@:)TL_5H@:*$XU4V0)/W4*7W3V5X[T1*'VB'L:8TX=1FL_5H@:*ESW4*8*?G?V4F0_5H@:*F0*7W3V5X\_5H@:*4K[?60M?FSX?J$&/Z@_5H@:*DP_5H@:*D[V2&0'?V/U56P_5H@:*(CV1FKX1'46:Z(U1H`C<'3V5X[T1*'VB'L:8TOA?FSXB'L:8T\=?*T-8X?A?V0Z/ZT-8X?A*F/_/W4VB'L:8T[>/GG^2*T-8X?A)VK]B'L:8T[O1'46:Z(U1H`C;)4'/WPAB'L:8TW=1*(_5H@:*DOQ074_5H@:*HK_29G^/VTUB'L:8TS@1*T-8X??9*T-8X?@)ZT-8X??-6O_B'L:8T[>1FKXB'L:8T[Y4(0'/WPA/6D_5H@:*DWV=J,_5H@:*(CX?J$&/Z?V0JT-8X?A)ZT-8X??9&0'B'L:8T[=/ZT-8X?@)WG^2*T-8X?A)ZT-8X??)JT-8X??)F7[B'L:8T[V7X`(:Y$GB'L:8TW=1*(_5H@:*DOQ074U2&XLB'L:8TT:/VTU4VD_5H@:*(D_5H@:)TW`1V09,&SV?G?V2*CZ?G4G4&0.:F'[B'L:8T[@B'L:8T[><ZT-8X??9&8)B'L:8T[O4V8+/V,,1VSV1FKX1'468Y$C<'3V5X[T1*T-8X?A*:T-8X?A)U']1JT-8X?A.&4'@7@_5H@:*HL*/W<_5H@:*DP'4X0'/WPAB'L:8TW=1*'VB'L:8TOAB'L:8T\=2*T-8X?A.*,SB'L:8T\VB'L:8T[>@V/Y/VSV4*T-8X?A)F/U56O_/VK]06D'7X`(:Y$G4&0.:F(_5H@:*F<T/U\_5H@:*ET'B'L:8T\=B'L:8TT;29G^B'L:8T[>2*,*1&SU56O_/VK]06D'7W3V5X[T1*'V=J+_0:,_5H@:*HD&/ZT-8X?>9&/Y/VSV4*/V/GG^2*T-8X?A)VK]0:T-8X?A0G46:W8B;)3T1*T-8X?A*6/QB'L:8T[O4*+_29G^/ZT-8X??9*,*1&T[26OV8JT-8X?@*68+B'L:8T[O?60G4&0.:JT-8X?@)JT-8X?A0J'V<ZT-8X??9&8)07?X5&/U5:T-8X??8VSV1FL_5H@:*ES[4(/=;)$C<'3V5X[T1*'V+6K]0:T-8X?A*'4_5H@:)TL_5H@:*$XU4V0_5H@:*J'V4'@64&0.:F'[?60MB'L:8T\=2*T-8X?A.*,S3V0Z/V;V2*T-8X?A)ZT-8X?A/Z/V/GH_5H@:*(?_/VK]06D'7X_^:Y$G4&0.:F'[?6/Q0:T-8X?A/ZT-8X?A9FT_5H@:*%TL1V/_?G?[B'L:8TT;/GH_5H@:*(?_/VK]06D'7W3V5X[T1*'V.F8'B'L:8T\=B'L:8TT;29G^/VTU4ZT-8X?A0FSUB'L:8TSLB'L:8TT:2&/]1F7[4(0'/WPA/:T-8X?A0J'VB'L:8TOA?FSXB'L:8T\=?'/V@V/Y/VT_5H@:*DP_5H@:*F0_5H@:*DKV/GG^2*T-8X?A)VK]0:T-8X?A0G46:W8B;)3T1*(_5H@:*DOQ074U2&X_5H@:*6;^/VTU4VC_A&W^/X<K1*T-8X?A*7L&5FLG4&0.:F'[?60J2&8_5H@:*J'X4V8_5H@:*$[V/GG^B'L:8TT;/VK]0:T-8X?A0G46)I$C<&(_5H@:*F<T/U[XB'L:8T[VB'L:8T\=2&XL1V/_?G?[2*C`1V09+:(_5H@:*DXG4&0.:F'[?60M?FSX?J$&/Z?V0F/_B'L:8T[>B'L:8T[V?V0_5H@:*4P,1VT_5H@:*DO]1F8_5H@:*F<'7X_^:Y$C;)$G4&0.:F'[B'L:8T[@/U(_5H@:*$K]B'L:8T[O0'4X4ZT-8X?A9JT-8X??*:T-8X?A)W<_5H@:*DP'4X0'/WPA/6DT/YLU2&8U?'0_5H@:*DPZ/V;V2&0'?V/UB'L:8TSL1VSV1FKX1*T-8X?A/X0B1X`C<'3V5X[TB'L:8T[Y?:T-8X?A)YCV4V@_5H@:*F<T,74+1'7VB'L:8TW>56O_/VK]06D'7W3V5X[T1*'V=J+_0:,_5H@:*HD&/Z?V0F/_/ZT-8X?A/Z/V/JT-8X??-6O_/VL_5H@:*$KX1'46:VPB;)4BA&SX4J8*?FT*:Y4'/WPAB'L:8TW=1*T-8X?A*60J2&8)B'L:8T[O4V8+/V,,1VSVB'L:8TS=1F7[4(088X8C;)$G4&0.:JT-8X?@)FD_5H@:*DWVB'L:8TWOB'L:8TS@/VTUB'L:8TS@06D'@7@U4V0_5H@:*J(_5H@:*DP'4X0'/WPA/6DT/ZT-8X?>*J+_0:T-8X?A9JT-8X?A9'/VB'L:8TW@/Z0&?FTU4V7[4*8*?JT-8X??*60)/W4*7W?`1V/[0H/HB'L:8T[V4TL_5H@:)HDC<(_X:Y4'/WPA/:T-8X?A0J'VB'L:8TP:B'L:8TT;07;X4ZT-8X?A.'CV/GG^2&/]B'L:8TS=06D'7X@C;)4'/WPAB'L:8TW=1*(_5H@:*DOQ074_5H@:*HK_B'L:8TSO=6OV2*,*B'L:8T[YB'L:8TT;B'L:8TW>5:T-8X??8ZT-8X??9*T-8X?A)VK]B'L:8T[O1'464&0.:F'[?60M?FSX?JT-8X?A9'/V@ZT-8X?A)V;V2&0_5H@:*F0_5H@:*DL_5H@:*DP_5H@:*4P,B'L:8TT:2&/]B'L:8TS=06D'7X_X:Y$G/6D_5H@:*DWV.F8'?FS`=6P_5H@:*DP_5H@:*(DU4ZT-8X?A0FT[26OV8I7V1FL[0Z,_5H@:*F0G4&0.:F(_5H@:*F<T/Y?_1&OV2'@_5H@:*%TZ/ZT-8X?A*F/_B'L:8T[>B'L:8T[V?V0_5H@:*4P,1ZT-8X??9&/]1JT-8X?A.&D_5H@:*F064&0.:F'[?:T-8X?A)YLU2&8_5H@:*HLS3V0_5H@:)XCV0F/_/W4_5H@:*DKV/JT-8X??-6P_5H@:*(CV1JT-8X??)JT-8X?A.&D'7X_^:Y$G:Y7V4&4*0X`C;)4'/WPA/6D_5H@:*DWV+6K]064'@7@U4V0)/W4*7W3V5X[TB'L:8T[Y?60MB'L:8T\=B'L:8TT;B'L:8T[O?J$&/Z?V0F/_/W4V/V,_5H@:*%G^2&/]B'L:8TS=06D'7X_X:Y$G4&0.:JT-8X?@)FDTB'L:8T[>.F8'?FS`=6OVB'L:8TT;?G?[2&,,1VSV1FKXB'L:8T[YB'L:8T[V7W3V5X[T1*(_5H@:*DP_5H@:)T\_5H@:*HK_B'L:8T[O?J$&/Z?V0F/_B'L:8T[>4*/VB'L:8TW>56O_/VL_5H@:*$KX1'46:V8B;)3T1*'V.F8'?FS`=6OV2*,*1&T_5H@:)TW`1V09+:(T<'3V5X[T1*'V<ZT-8X??9&8)07?X5&/U56O_/VK]06D_5H@:*F069I$C;)4'/WPA/6DT/ZT-8X?@9JT-8X??)FKXB'L:8T[?4*T-8X?>)G@_5H@:*HL*B'L:8T[>4F0_5H@:*F0*7W3V5X\_5H@:*4K[?60M?FT_5H@:*ETUB'L:8T\;3V0Z/V;V2*T-8X?A)W4V/V,,1VSV1FKX1'46:Z(B;)4'/WPA/6D_5H@:*DWVB'L:8TX;074U2&XL1V/_?G@_5H@:*F;_/JT-8X??-:T-8X??8ZT-8X??9&/]1JT-8X?A.&D'7W3V5X\_5H@:*4K[?60_5H@:)T\U2&8U?*T-8X?A?V0Z/ZT-8X?A*F/_B'L:8T[>4*0_5H@:*DOU56O_/ZT-8X??)FKXB'L:8T[YB'L:8T[V7X`T:Y$GB'L:8TW=1*'V.F8'?FT_5H@:*%TL1ZT-8X?A)VT_5H@:*HL*1*T-8X??9*C`1V09+:(T<'3V5X\_5H@:*4K[?6/Q0:T-8X?A/Z+_B'L:8TSO=6P_5H@:*DP_5H@:*(DU4VC_/GG^2&/]1F7[B'L:8T[V7W3V5X[T1*'V.JT-8X?A.'4U2*T-8X??.)G^/ZT-8X??9*,*1&SUB'L:8TSL1VSV1JT-8X??)F8_5H@:*F<'7W3V5X[TB'L:8T[Y?:T-8X?A)ZT-8X?@9JT-8X??9&T_5H@:*HK`,74T/WH_5H@:*DO_B'L:8TW>56O_B'L:8T[>1FKX1'464&0.:F'[B'L:8T[@/YLUB'L:8TT;0:,S3V0Z/V<_5H@:*DO_B'L:8T[>4*/V/GG^2&/]1F7[4(0B1X`C<'3V5X[T1*'VB'L:8TOAB'L:8T\=B'L:8TT;0:,S3ZT-8X?A)Z@_5H@:*DOY/VSVB'L:8T[V?V0_5H@:*4P,1VT_5H@:*DO]1F7[4(0B08`C;)3T1*(_5H@:*DOQ074_5H@:*HL_5H@:*(C`=:T-8X??8V/_?G@_5H@:*F;_B'L:8TO@B'L:8TSO1V09@7L_5H@:*HD*2*,V4Y4'/WPAB'L:8TW=1*'V<VSX4F8*07CVB'L:8TW>5:T-8X??8VSVB'L:8TS=1F7[4(/@-9$C<&'[?6/QB'L:8T[O4*+_29H_5H@:*(@_5H@:*DO_B'L:8T\=4VC_B'L:8TO@26OV8JT-8X?@?7L_5H@:*J0_5H@:*$X_5H@:*ES^3VXG4&0.:F'[?60_5H@:*4L_5H@:*HL_5H@:*$L*B'L:8TW>5:T-8X??8ZT-8X??9*T-8X?A)VL_5H@:*$KX1'464VW^/VCY7U8_5H@:*F0*B'L:8TK=9)$G4&0.:JT-8X?@)JT-8X?A0JT-8X?A*60K/W?Z1*'H4'C[46/U56O_B'L:8T[>1FKX1'464&0.:F'[?60K/ZT-8X??*6?[?:?V0JT-8X?A)VSV4*/V/GH_5H@:*(?_/VK]06D'7W3V5X[T1*'VA&W^/Z?V0F/_/W4VB'L:8T[>/GG^B'L:8TT;/VL_5H@:*$KX1*T-8X?A/X0B@6W]4V0)8IDU4V@B;)4B<VD.:Y$G4&0.:JT-8X?@)FDTB'L:8T[><VSX4JT-8X?A.'?XB'L:8TSA/ZT-8X?@)WG^2&/]1F7[B'L:8T[V7TLC<'3V5X[TB'L:8T[YB'L:8T[@/YLU2&8_5H@:*HL_5H@:*HD_5H@:*J0_5H@:*DPZ/V;V2&0'?ZT-8X?A)V,,1ZT-8X??9&0_5H@:*$K]0:T-8X?A0G46:V8B;)$C;)$C;)4'/WPA/6DTB'L:8T[>=&0_5H@:*$WZ1*(Z/ZT-8X??*7L_5H@:*(D'@7@UB'L:8TS@/W<_5H@:*DP_5H@:*F0*7W3V5X[T1*'V.F8'?FS`=:T-8X??8V0_5H@:*(DU4VC_/GG^2*T-8X?A)ZT-8X??)FL_5H@:*ES[4(0'/WPAB'L:8TW=1*'V=J,_5H@:*(CX?J$&B'L:8T[>@V/YB'L:8T[>2&0_5H@:*F0V/V,,B'L:8TT:2&/]B'L:8TS=06D_5H@:*F06:Z(B;)3T1*'V.F8_5H@:*F0U2&XL1V/_B'L:8T\=4VD_5H@:*(D[2:T-8X??8V09='L&4V7^3VXG4&0.:JT-8X?@)FDT/ZT-8X?>*J+_0:,S3V0Z/V;V2&0'B'L:8T[=B'L:8T[>B'L:8TW>56P_5H@:*(CV1FKX1'46:Z,B;)$C2Y#P5*+_:G0=3XL&9HKB4&0.:F'[?:T-8X?A)YCVB'L:8T\TB'L:8T\;/VTK/W?ZB'L:8T[Y?6\I?G;V*X`H1&4B<*?V4WK_4*C`1V/B4&0.:F(_5H@:*F<_5H@:*DWVB'L:8TO@B'L:8TSO1V0Z/ZT-8X?A*JT-8X?A)VSV4*0_5H@:*DP64VW^/VCY7ZT-8X?@*6D-?'/V;)$GB'L:8TX=4W?_0:T-8X?A9'L*B'L:8T[>1D`6=&0_5H@:*J(_5H@:*HCV2%(*4ZT-8X??9&8S5G@_5H@:*DO];&,'B'L:8TS>B'L:8T\T8JT-8X?>8Z+_1JT-8X?A)X0*26OV1&<6=&0_5H@:*J(_5H@:*HCV2*T-8X?@9JT-8X??*7?_B'L:8T[O?'L*/VLC<&,'5JT-8X?A?8;G/W@I?JT-8X?A?6/]7W?`1V/[0H0_5H@:*:'V4J#VB'L:8TT;+7@*2&8S5G@_5H@:*DO];)$\9*LC2UX_5H@:*J0=3XL&9HL9<Z+_?G<_5H@:*DP*/VS]8E(_5H@:*DXT7W3V5X\_5H@:*4L_5H@:*F<_5H@:*DWV<ZT-8X?A9JT-8X??9*,_5H@:*J'V4V/_.V0V3Z+_?JT-8X??*:T-8X?A.*T-8X?A0G3U56O_/VL_5H@:*$KX1'464VW^/VCY7U`_5H@:*F<-?'/V;)4B58`C;%X&9G0=3XL=8I@U2*,)/W?VB'L:8TT;B'L:8TS=8E(_5H@:*DXT7W3V5X[TB'L:8T[Y?60_5H@:)X@U2*,)/ZT-8X??*:T-8X?A)VSR/Z0&?FTU4V7[4*T-8X?@)WG^2&/]B'L:8TS=B'L:8T[O1'464VW^/VCY7U8'4ZT-8X?=)HDC<(`':Y$C.70_5H@:)HL&9G0_5H@:)HL=8J8*B'L:8T\=4V0)/W4_5H@:*$X_5H@:*$L9+:(T@Z,'0&064&0.:F'[?60XB'L:8TS@?G?VB'L:8T\T/W4*A:Ka4&0.:F'[?60M?JT-8X??9&8U?*T-8X?A?V/R/Z0&?FT_5H@:*HL*06D'@7@U4V0)/W4*7W?`1V/[0H/H4'?=9)$G:WLB<'3V5X[T1*'V=&0_5H@:*$WZB'L:8T[YB'L:8T[@,:T-8X?A/WC[46/U56P_5H@:*(CVB'L:8TS=B'L:8TS=06D'7W3V5X[T1*'V=&0*0VDT@V0_5H@:*D\_5H@:*DP_5H@:*(CV4*/V/GG^2&/]1F7[B'L:8T[V7W3V5X[T1*'VA&W^/Z?VB'L:8T[A/VSV4*0_5H@:*DOU56P_5H@:*(D_5H@:*DO]1F7[B'L:8T[V7X_V0F4B;)4B=(`C<'3V5X[T1*'V=JT-8X?A9FSXB'L:8T\=?'/V@V/Y/ZT-8X??9&0_5H@:*F0V/ZT-8X?@)ZT-8X??-:T-8X??8VSV1JT-8X??)F7[4(0B4(`C;)$G4&0.:F(_5H@:*F<TB'L:8T[>=J+_0:T-8X?A9JT-8X?A9'/VB'L:8TW@/Z0_5H@:*J0U2*,*06D'@7@UB'L:8TS@/ZT-8X?A?60'4X0*26OV1&<6.VD-?'/V;)4B1(`G4&0.:JT-8X?@)JT-8X?A0J'V<VSX4F8*07D_5H@:*DOU56O_/VK]06D_5H@:*F069I$C<'3V5X[T1*'VB'L:8TWO4V/_?G@_5H@:*ES[4*8_5H@:*$XU4V0_5H@:*J'V4'@64&0.:F'[B'L:8T[@/YL_5H@:*HK_B'L:8T[O?J$_5H@:*J/V.V0_5H@:*DL_5H@:*J0UB'L:8TT;B'L:8T\=B'L:8TS@06D_5H@:*F0XB'L:8TS@?G?V4F0'B'L:8TS@7W?`1V/[0H/HB'L:8T[V4TL_5H@:)HDC<(_X:Y4'/WPAB'L:8TW=1*(_5H@:*DPJ2*T-8X?A.';X4V8+B'L:8T[>/GG^2*T-8X?A)ZT-8X??)FKX1'468Y$C<'3V5X[TB'L:8T[YB'L:8T[@/U[X4*+_2:T-8X?@0FP_5H@:*DP_5H@:*(D_5H@:*HL*1&T_5H@:*4P,1VT_5H@:*DO]1F8_5H@:*F<'7W3V5X[T1*T-8X?A*60M?JT-8X??9&8U?'/V@V/Y/ZT-8X??9*T-8X?A)W4VB'L:8T[>/GG^2&/]B'L:8TS=06D_5H@:*F06:V8B;)3T1*'VB'L:8TX;074U2*T-8X??.)H_5H@:*(?VB'L:8TT;?G?[B'L:8TT;A&W^/X<H/ZT-8X??)FL[0Z,_5H@:*F0G4&0.:F'[?60M?FSX?J$&/ZT-8X?>9&/Y/VSVB'L:8T[VB'L:8T[=/ZT-8X?@)WG^2&/]1F7[4(0B5H`C;)4'/WPA/6DTB'L:8T[>+:T-8X??)JT-8X??)F8_5H@:*DT'@7@UB'L:8TS@/W;V4'@64&0.:JT-8X?@)FDT/YLU2&8U?'/VB'L:8TP;/V;V2&0'?V/U56O_/VK]06D'7X_X:Y$G4&0.:F(_5H@:*F<T/U[X4*T-8X?A9JT-8X??9&XL1ZT-8X?A)VT_5H@:*HL*1&SU5:T-8X??8ZT-8X??9&/]1F7[4(0'/WPA/6DT/YLU2&8U?'/V@V/Y/VSV4*/VB'L:8TW>B'L:8TSL1VT_5H@:*DO]1JT-8X?A.&D'7X_X:Y$G/6DT/U[X4*+_B'L:8TSO=6P_5H@:*DO_?JT-8X??*6C_A&W^B'L:8T[>8E(T?94'/WPA/6DT/ZT-8X?>8ZT-8X??9&8)B'L:8T[O4V8+B'L:8T[>/GH_5H@:*(?_/ZT-8X??)FL_5H@:*ET_5H@:*F<'7XLC;)$G4&0.:F(_5H@:*F<TB'L:8T[>+6L_5H@:*$KXB'L:8T[?4*8*?JT-8X??*60_5H@:*J'V4'@64&0.:F'[?60M?FSX?J$&/Z?V0JT-8X?A)VSV4*/VB'L:8TW>56P_5H@:*(CV1FKX1'46:VDB;)4'/WPA/:T-8X?A0J(_5H@:*DP_5H@:*8D_5H@:*ET'?FS`=:T-8X??8V/_?G@_5H@:*F<_5H@:*(CU56O_/VK]B'L:8T[O1'464&0.:F(_5H@:*F<_5H@:*DWV=J,_5H@:*(D_5H@:*ETUB'L:8T\;3V0Z/V;V2&0'?V0_5H@:*4P,1VSV1FKX1*T-8X?A/X0B1(`C<*T-8X?@)FDT/U[X4*+_29G^B'L:8T[>2*T-8X?A9G?[2*T-8X?>*6X_5H@:*(?V8ID-3W?X1ZT-8X?A?ZT-8X??.)4'/WPA/6DT/U'_0'L)/ZT-8X?A/ZT-8X??*:?V0F0_5H@:*(CV4*/V/GG^B'L:8TT;/VK]B'L:8T[O1'46:WHB;)$C;)4'/WPA/6DT/YCVB'L:8TS@0VDT@V0_5H@:*$X-2'4X4ZT-8X?A9G?V4F0'B'L:8TS@7W3V5X[T1*'VB'L:8TOAB'L:8T\=2&8U?'/V@V/YB'L:8T[>2&0'?ZT-8X?A)V,,B'L:8TT:2*T-8X?A)ZT-8X??)FKX1*T-8X?A/X0B1(`C;&`C.7DU2(\&3W0_5H@:)HL_5H@:*J0=B'L:8TL=*W3V5X[TB'L:8T[YB'L:8T[@/V(_5H@:*F<'1G?_5J0*B'L:8T[Y2(0C.70_5H@:*J0_5H@:*J0=3ZT-8X?=9JT-8X?=9H<X4Z,*/W;VB'L:8T[V4VL9+:(_5H@:*DX64&0.:F'[?60K/W?Z1*'HB'L:8T[V5&D_5H@:*J#VB'L:8TW>56O_/VK]06D'7W3V5X\_5H@:*4K[?6/D2*T-8X??9*T-8X?A9FWH4*'V56/_B'L:8TW>5:T-8X??8VSV1FKX1*T-8X?A/X0'/WPA/6DTB'L:8T[>B'L:8TXTB'L:8T[>4V?[?58_5H@:*F0_5H@:*$[[B'L:8T\S/V,_5H@:*%G^2&/]B'L:8TS=0:T-8X?A0G464&0.:F'[?:T-8X?A)ZC`1V0L0F,,1ZT-8X??9&/]1JT-8X?A.*T-8X?A0G464VW^/VCY7U[[1'/V?G4C;)4B,&0*/&7V3Z']:Y$G4&0.:F'[?60JB'L:8TT;B'L:8T[O4F8*07CV/GH_5H@:*(?_/ZT-8X??)JT-8X??)JT-8X?A.&D'7XLC;)4B@60*=J,&5F0B<'3V5X\_5H@:*4L_5H@:*F<TB'L:8T[>B'L:8TP:2&8)0:T-8X??*68+/V,_5H@:*%G^2&/]1F7[4(0'5G0&;)4'/WPA/6DT/ZT-8X?>8VSXB'L:8T\T07?X5&0_5H@:*4P,1VSVB'L:8TS=1JT-8X?A.&D'7X_D.J?D/5'R+5\Z+5'Q@U(B;)$C.7DU2(\&9HL=3W0_5H@:)HKB4&0.:JT-8X?@)FDTB'L:8T[>=&0)?&/_=&0*0VD_5H@:*DWa@V0*5FT'A&W^/T`'/WPA/6DT/ZC`1ZT-8X?A)Z?V0F0_5H@:*(CVB'L:8T[V?V064VW^/VCY7U_[B'L:8TS>?'0_5H@:*DPC;)4IB'L:8T\=B'L:8T\T/T`B0H_b.70=B'L:8TL=9JT-8X?A?W0_5H@:)HL9<Z+_?G;V4ZT-8X?A)VS]8JT-8X?@9J(T7W3V5X\_5H@:*4K[?:T-8X?A)Y@U2*,)/W?V2%`_5H@:*DPV3Z+_?G?XB'L:8T[Y4&,,1VT_5H@:*DP_5H@:*$K]0:T-8X?A0JT-8X?A/X0*26OV1&<6.ZT-8X?A0GL_5H@:*HD&/Y$G:Z(B;)#P3ZT-8X?=9HL=3W0=8J8*?G?V4F0_5H@:*F0*1H;D?:(64&0.:F'[?60M?FSXB'L:8T\=?*T-8X?A?V/R/Z0&?FTU4V7[4*8*?G?VB'L:8T\T/W4*7W?`1V/[0H/RB'L:8T[YB'L:8TS>?'/V;)4B58`G4&0.:F(_5H@:*F<T/U[XB'L:8T[V?FS`=6OV2*,*B'L:8T[YB'L:8TT;/JT-8X??-:T-8X??8VSVB'L:8TS=1F8_5H@:*F<'7W3V5X\_5H@:*4K[?6/Q074UB'L:8TT;29H_5H@:*(?VB'L:8TT;?G?[2&,_5H@:*%H_5H@:*(?_/ZT-8X??)FL_5H@:*ES[4(0'/WPA/6DT/Y?_B'L:8T[YB'L:8TT:/VT*B'L:8TSO@V/Y/VSV4*0_5H@:*DOU56O_B'L:8T[>1FKX1'464&0.:F'[B'L:8T[@/V#XB'L:8T[>3Z(Z/V;V2&0'?V/U5:T-8X??8VSV1FL_5H@:*ES[B'L:8T[V7W3V5X[T1*'VA&W^/Z?V0F/_B'L:8T[>B'L:8T[VB'L:8T[=/V,_5H@:*%G^2&/]1F7[4(0*26OV1&<6.FC[3V0U4)$C<(_S?G/]/Z8*2&8'0(`C<(`H/W3W4V@B;)3T1*(_5H@:*DOQ074U2&XLB'L:8TT:/VTU4VC_A&W^/X<_5H@:*4WX5&8T/Y4'/WPA/6DTB'L:8T[><VSX4F8*07CV/JT-8X??-:T-8X??8VSV1JT-8X??)F8_5H@:*F<_5H@:*F069HDT;)$G/6D_5H@:*DWVB'L:8TX;074_5H@:*HK_2:T-8X?@0FOV2*,_5H@:*$W[2*D_5H@:*%S^B'L:8T[>8ID_5H@:*$P_5H@:*J0*06P&294'/WPA/6DT/YCV4V@_5H@:*F<T,74+1'7V/GG^2&/]1JT-8X?A.*T-8X?A0G464&0.:F(_5H@:*F<T/ZC`1V0Z/ZT-8X?A*F0_5H@:*(CV4*/V/GH_5H@:*(?_/VL_5H@:*$KX1'46:Z7`1G?V4H<K?G?Z:Y$G:Z?[5G4T:Y4'/WPA/:T-8X?A0J'V<VSXB'L:8T\T07?X5&0_5H@:*4P,1VSV1FKX1*T-8X?A/X0:?9$G4&0.:F'[?60J2&8)07?XB'L:8TSAB'L:8T[>/GG^2&/]1F7[B'L:8T[V7XLC;)$C;%X&9HL=B'L:8T\VB'L:8T\V9H<X4Z,_5H@:*$WV4F0'B'L:8TS@1H;D?:T-8X?A*80'/WPA/6D_5H@:*DWVB'L:8TXT/ZT-8X??*6?[?:?V4ZT-8X??)VT'@7@_5H@:*HL*/ZT-8X?A?60'B'L:8TS@7W3V5X[T1*(_5H@:*DOQ074U2&XL1V/_?JT-8X??*6C_/GG^2*T-8X?A)VK]06D'7W3V5X[TB'L:8T[YB'L:8T[@/U[X4*+_29G^/VTU4VD_5H@:*(CU56O_/VK]06D'7W3V5X[T1*T-8X?A*:T-8X?A)U[X4*+_29G^/VTU4VD_5H@:*(CUB'L:8TSL1VT_5H@:*DO]B'L:8TS=06D'7W3V5X[T1*'V<VSXB'L:8T\T07?XB'L:8TSA/V,,1VSV1FL_5H@:*ES[4(/O*)$G/6DT/U[X4*T-8X?A9FS`B'L:8TWY1V0_5H@:*(DUB'L:8TS@B'L:8T[Y2*C`1ZT-8X?A)X<KB'L:8TS>B'L:8T\V4V7^3VXG4&0.:F'[?60K/ZT-8X??*6?[?:T-8X?@.'4_5H@:*$[[46/U56O_B'L:8T[>1FKX1'464&0.:F'[?60[26OVB'L:8TP;/V;V2&0_5H@:*F0_5H@:*DKV/GH_5H@:*(?_B'L:8T[>1FKX1'46:V/Y0(`C<(`H1&4B<'3V5X[TB'L:8T[Y?60M?FSX?J$_5H@:*J/VB'L:8TP;/V;VB'L:8TT;/W4V/ZT-8X?@)ZT-8X??-6P_5H@:*(CV1FKXB'L:8T[Y4(0B58`C<'3V5X[T1*'V<VSX4F8_5H@:*$WX5&/UB'L:8TSL1ZT-8X??9&/]B'L:8TS=06D'7UHC;)$G/6D_5H@:*DWV.F8'B'L:8T\=2&XLB'L:8TT:/VTU4VC_A*T-8X??.&OV8E(TB'L:8T[@<'3V5X[T1*'V.F8'B'L:8T\=2&XL1V/_?G?[2&,,1VSVB'L:8TS=1F7[B'L:8T[V7W3V5X[T1*'V.F8'B'L:8T\=B'L:8TT;29G^/ZT-8X??9*T-8X?A9G?[B'L:8TT;/JT-8X??-6O_/VK]06D_5H@:*F064&0.:JT-8X?@)JT-8X?A0J'V.F8'?FT_5H@:*%TL1ZT-8X?A)VTUB'L:8TS@1&SU56O_/VK]B'L:8T[O1'464&0.:JT-8X?@)FDT/ZT-8X?@9&8_5H@:*F0U2&XL1V/_?JT-8X??*6C_B'L:8TW>56O_/VK]06D'7W3V5X[T1*'V.F8'?FS`=6OV2*,*1&SU56O_/VL_5H@:*$L_5H@:*ES[4(0'/WPA/6DT/ZT-8X?@9&8'?FS`=6OVB'L:8TT;?G@_5H@:*F;_/GG^2&/]B'L:8TS=B'L:8T[O1'464&0.:F'[?:T-8X?A)U[X4*+_29G^/VTU4VC_/GH_5H@:*(@_5H@:*(CV1FL_5H@:*ET_5H@:*F<'7W3V5X[T1*(_5H@:*DOQ074UB'L:8TT;B'L:8TSO=6OV2*,*1*T-8X??9&,,1VT_5H@:*DO]1F7[4(0'/WPAB'L:8TW=1*'V.F8'?JT-8X??9&XL1V/_?G@_5H@:*F;_/GG^2&/]B'L:8TS=06D'7W3V5X[T1*(_5H@:*DP_5H@:)X@_5H@:*(CX4F8*B'L:8T[O5*T-8X?A)V,,1VSV1FKX1'46)H??*9$G/:T-8X?A0J'V.F8'?FS`=6P_5H@:*DO_?G?[B'L:8TT;A&X_5H@:*(?V8ID-3ZT-8X??*68_5H@:*(@&294'/WPAB'L:8TW=1*T-8X?A*60_5H@:)X@_5H@:*(CX4F8*07CV/JT-8X??-6O_/VK]B'L:8T[O1'46;HLC;)3T1*'V.F8'?FS`=6OV2*,*1&T_5H@:)TW`B'L:8TT:/X<K5G0*06P_5H@:*J/`<'3V5X[T1*(_5H@:*DPKB'L:8T[>B'L:8TS@0VD_5H@:*DWH4*T-8X??*FD(/V,_5H@:*%G^2&0_5H@:*$K]06D'7W3V5X\_5H@:*4K[?60K/W@_5H@:*EG[?:?VB'L:8T[A/VT_5H@:*DP'?V/U5:T-8X??8ZT-8X??9&/]1F7[4(0'/WPA/6D_5H@:*DWVA&W^/Z?V0F/_/W4V/ZT-8X?@)WG^2&0_5H@:*$K]06D'7X_V0F4B;)4B<6CW:Y$G4&0.:F(_5H@:*F<_5H@:*DWVB'L:8TOA?FSX?J$&B'L:8T[>@V/Y/VT_5H@:*DP'?V/UB'L:8TSLB'L:8TT:B'L:8TT;/ZT-8X??)FKX1*T-8X?A/X0B58`C<'3V5X\_5H@:*4K[B'L:8T[@/Y@_5H@:*(D_5H@:*ET)07@_5H@:*ET+/V,,1VSV1JT-8X??)F7[4(/>;)$C<&(_5H@:*F<_5H@:*DX_5H@:*DOQ074UB'L:8TT;B'L:8TSO=6OV2*,*1&T[26OV8E(T?94'/WPA/6DTB'L:8T[>.F8_5H@:*F0UB'L:8TT;29G^B'L:8T[>2*,*1*T-8X??9&,_5H@:*%G^2&/]B'L:8TS=0:T-8X?A0G464&0.:F'[?6/Q074U2&XL1V0_5H@:*(DUB'L:8TS@1&SU56O_/ZT-8X??)JT-8X??)JT-8X?A.&D_5H@:*F064&0.:JT-8X?@)FD_5H@:*DWVB'L:8TX;074UB'L:8TT;29G^/VTU4VC_/GG^2&/]1F7[4(0'/WPA/:T-8X?A0JT-8X?A*60M?FSX?J$&/Z?V0F/_/W4VB'L:8T[>/GH_5H@:*(?_/VK]06D'7X`,:Y$G/:T-8X?A0J'VB'L:8TX;074U2*T-8X??.)G^/ZT-8X??9*,*1&T[26OV8ID_5H@:*$P&4V8_5H@:*(@&B'L:8TSO<'3V5X[T1*'VB'L:8TX;074U2&XL1V/_B'L:8T\=4ZT-8X?A0JT-8X??9&,,1VT_5H@:*DO]1JT-8X?A.&D'7W3V5X[TB'L:8T[Y?:T-8X?A)YLU2&8U?'/V@V/Y/VSVB'L:8T[V?ZT-8X?A)ZT-8X?@)WG^2&/]1JT-8X?A.&D'7X`,:Y$GB'L:8TW=1*'V.F8'?JT-8X??9&XLB'L:8TT:/ZT-8X??9*,*1&T[B'L:8TSO1V09='L&4V7^B'L:8T\VB'L:8TSO<'3V5X[T1*'V<VSXB'L:8T\T0:T-8X??*:T-8X?A.'D_5H@:*DP_5H@:*4P,1VSV1FKX1'46)ES?)HDC;)$G/6DT/ZT-8X?@9&8'?FS`B'L:8TWY1V/_?G?[2*D_5H@:*%S^B'L:8T[>8ID-3W?X1W0_5H@:*%TG4&0.:JT-8X?@)FDTB'L:8T[>.F8'?FS`=6OVB'L:8TT;B'L:8T\=4ZT-8X?A0FSU56O_/VK]06D'7W3V5X[T1*'V.F8'?FS`=6P_5H@:*DO_?JT-8X??*6D_5H@:*(CU56O_/VK]06D'7W3V5X[TB'L:8T[Y?:T-8X?A)YLUB'L:8TT;0:T-8X?A9J$&/Z?V0F/_/W4V/V,,B'L:8TT:2&/]1F7[4(0B58`C<&'[?:T-8X?A)U[XB'L:8T[V?JT-8X??9&XL1V/_?JT-8X??*6D_5H@:*(D[B'L:8TSO1V09='L&B'L:8TS@06P&B'L:8TSO<'3V5X[T1*'V=J,_5H@:*(CX?J$_5H@:*J/VB'L:8TP;/V;V2&0_5H@:*F0V/V,,1VT_5H@:*DO]1F7[4(0B58`C;)3T1*'V.F8'?FT_5H@:*%T_5H@:*6<_5H@:*(?V2*,*B'L:8T[Y2*C`1V09B'L:8TXT5G0_5H@:*$WX1W/`<'3V5X\_5H@:*4K[?60M?JT-8X??9*T-8X?A.*,S3V0Z/V;VB'L:8TT;/W4V/ZT-8X?@)WH_5H@:*(@_5H@:*(CV1FKX1'46:WHB;)$C<*T-8X?@)JT-8X?A0JT-8X?A*60_5H@:*8CX4*+_2:T-8X?@0JT-8X??8ZT-8X?A)VTU4VC_B'L:8TO@26P_5H@:*DP9B'L:8TXT5G0_5H@:*$X_5H@:*ES^3VXG4&0.:F'[B'L:8T[@/YLU2&8_5H@:*HLSB'L:8T\V/ZT-8X?>9&/YB'L:8T[>2&0'?V/U56O_B'L:8T[>1FKXB'L:8T[Y4(0B58`C;)$G/6DT/U\_5H@:*ET'?FT_5H@:*%TL1V/_?G?[2*C`1V09+:(_5H@:*DXG4&0.:F'[?6/QB'L:8T[O4*T-8X?A9FS`=6OV2*T-8X?A9G?[B'L:8TT;/GG^2&/]1F8_5H@:*F<_5H@:*F064&0.:F(_5H@:*F<T/Y?_07;XB'L:8TS@0:T-8X??*F/U56O_/VK]0:T-8X?A0G46;HCA.(K>8Y$G/6D_5H@:*DWV.F8'B'L:8T\=2*T-8X??.*T-8X?@0FP_5H@:*DO_B'L:8T\=4VC_B'L:8TO@B'L:8TSO1V09='L_5H@:*J0*06P&294'/WPA/6DT/YD_5H@:*DP_5H@:*$WZ1*'H4'D_5H@:*F<_5H@:*J#V/GH_5H@:*(?_/VK]B'L:8T[O1'464&0.:JT-8X?@)FDT/YCV4V?[?:?VB'L:8T[AB'L:8T[>2&0_5H@:*F0V/V,,1VSV1FKX1'464&0.:JT-8X?@)FDT/ZT-8X?>*:T-8X??.&OV@V/YB'L:8T[>B'L:8TT;/W4V/V,_5H@:*%G^2&0_5H@:*$K]06D'7X_V0F4B;)4B<6CW:Y$G4&0.:JT-8X?@)FDT/YLU2&8_5H@:*HLS3V0Z/V;V2*T-8X?A)W4V/ZT-8X?@)WG^2&/]1F7[4(0B58`C<'3V5X[T1*'V<VSX4JT-8X?A.'?X5&0_5H@:*4P,1VT_5H@:*DO]1F8_5H@:*F<'7TTC;)$C<*T-8X?@)JT-8X?A0JT-8X?A*6/Q074_5H@:*HK_29H_5H@:*(?V2*,*1*T-8X??9*C`1V09+:(T<'3V5X[TB'L:8T[Y?6/Q074U2*T-8X??.)G^B'L:8T[>B'L:8TT;?G?[2&,,B'L:8TT:2&/]1F7[4(0'/WPA/6DT/ZT-8X?@9&8'?JT-8X??9&XLB'L:8TT:B'L:8T[>2*,*1&SU5:T-8X??8ZT-8X??9*T-8X?A)ZT-8X??)FL_5H@:*ET_5H@:*F<'7W3V5X[T1*'V=J+_0:,S3V0ZB'L:8T[>0F0_5H@:*(CV4*/V/JT-8X??-6P_5H@:*(CV1JT-8X??)F7[4(0B58`C<&(_5H@:*F<T/U[X4*T-8X?A9FS`B'L:8TWYB'L:8TT:/VTU4ZT-8X?A0FT_5H@:)TW`B'L:8TT:/X<KB'L:8TS>3W@_5H@:*ET_5H@:*(@&294'/WPA/6DT/U[X4*+_29G^/VTUB'L:8TS@1*T-8X??9&,,1VT_5H@:*DO]1F7[B'L:8T[V7W3V5X[T1*'V=J+_0:,_5H@:*HD&/Z?VB'L:8T[A/VSV4*/VB'L:8TW>5:T-8X??8VSV1FL_5H@:*ES[4(0B58`C<&'[?6/QB'L:8T[O4*T-8X?A9FS`=6OV2*T-8X?A9JT-8X??*:T-8X?A0FT[B'L:8TSOB'L:8TT:/X<K5G0_5H@:*$WX1W0_5H@:*%TG4&0.:F'[?60J2&8)07?X5&/U56O_/VK]0:T-8X?A0G469H@;8XC@)I$C;)3T1*'V.F8'?FT_5H@:*%T_5H@:*6<_5H@:*(?V2*,_5H@:*$X_5H@:*F;_B'L:8TO@26OV8ID_5H@:*$P&4ZT-8X?A.*T-8X??8W/`<'3V5X[T1*'V.F8'?FS`=6OV2*,*1*T-8X??9&,_5H@:*%H_5H@:*(?_/ZT-8X??)FL_5H@:*ES[4(0'/WPA/6DT/YLU2&8U?'/V@V/Y/VSV4*/V/JT-8X??-6O_/VK]0:T-8X?A0G46:WHB;)3T1*T-8X?A*:T-8X?A)U[X4*+_29G^/VTU4VC_A&W^/X<KB'L:8TS>3W?X1ZT-8X?A?VXG4&0.:F(_5H@:*F<T/ZT-8X?>*JT-8X?A9JT-8X??9&8_5H@:*HL_5H@:*HD_5H@:*J/V@V/Y/VSV4*/V/GG^2&/]B'L:8TS=06D_5H@:*F06:WHB;)$C;)3T1*T-8X?A*6/Q074U2&XL1V/_?G?[2*D_5H@:*%S^/X<X5J$*B'L:8TT;?J0*<'3V5X\_5H@:*4K[?6/Q0:T-8X?A/Z,_5H@:*(C`=6OV2*T-8X?A9G?[2*T-8X?@)WG^2*T-8X?A)VL_5H@:*$KX1'464&0.:F'[?60J2&8)07?X5&/UB'L:8TSL1ZT-8X??9*T-8X?A)ZT-8X??)FKX1'469(L;-4\=*I$G/6DT/U[X4*+_29G^/VT_5H@:*HL_5H@:*$X_5H@:*F;_A&X_5H@:*(?V8JT-8X?@?7L&4V7^B'L:8T\V294'/WPA/6DTB'L:8T[>=&0*0VDT,74+1'7V/GH_5H@:*(?_/VK]B'L:8T[O1'464&0.:JT-8X?@)JT-8X?A0J'V=*T-8X?A)W@_5H@:*EG[?:T-8X?>9&/Y/VSV4*T-8X?A)F/U56P_5H@:*(CV1FL_5H@:*ET_5H@:*F<'7W3V5X[TB'L:8T[YB'L:8T[@/ZC`B'L:8TT:B'L:8T[>@V/Y/VSV4*/V/GG^2*T-8X?A)VK]06D'7X_V0F4B;)4B<6CW:Y$G4&0.:JT-8X?@)FDT/YLU2&8U?'/VB'L:8TP;/V;V2&0_5H@:*F0V/V,_5H@:*%G^2&/]1JT-8X?A.&D'7X`,:Y$G4&0.:F'[?60_5H@:)X?_B'L:8T[O4F8*07CV/GG^2&/]1F7[4(/=;)$C;)4_5H@:*4K[?6/Q074U2&XL1V/_?G?[2*C`B'L:8TT:/X;D?:(G4&0.:F'[?6/Q0:T-8X?A/Z+_29G^/VTU4VC_/GH_5H@:*(@_5H@:*(CVB'L:8TS=1F7[4(0'/WPAB'L:8TW=B'L:8T[YB'L:8T[@/YLU2&8_5H@:*HL_5H@:*HD&/Z?V0F/_/ZT-8X?A/Z/V/GG^B'L:8TT;B'L:8T[>1FKX1'46:WHB;)3TB'L:8T[Y?6/Q074UB'L:8TT;29G^/VTU4ZT-8X?A0FT[26OV8ID-3W?X1ZT-8X?A?VXG4&0.:F'[?6/Q074_5H@:*HK_B'L:8TSO=6P_5H@:*DO_?G?[2&,,1ZT-8X??9*T-8X?A)VK]06D'7W3V5X[T1*'V<ZT-8X??9&8)07?XB'L:8TSA/ZT-8X?@)WG^2&/]1F7[4(0;9ES>*$[L;)3T1*(_5H@:*DOQ074U2*T-8X??.*T-8X?@0FOVB'L:8TT;?G?[B'L:8TT;A&X_5H@:*(?V8ID-3W?X1W0_5H@:*%TG4&0.:JT-8X?@)FDT/ZT-8X?>*J+_0:,S3V0ZB'L:8T[>0JT-8X?A)VSV4*/V/GG^2&0_5H@:*$L_5H@:*$KX1'46:WHB;)$C;)3TB'L:8T[Y?:T-8X?A)U[X4*T-8X?A9FS`=6OV2*,*1&T[2:T-8X??8V09@7LS4VTU?W@G4&0.:F'[?:T-8X?A)U[X4*,_5H@:*(C`=6P_5H@:*DO_?G?[B'L:8TT;/GG^2&/]1F7[4(0'/WPA/:T-8X?A0J'V<ZT-8X??9&8)0:T-8X??*68+/V,,1VSV1FKXB'L:8T[Y4(/?-4W@*8@C<&(_5H@:*F<T/U[X4*,_5H@:*(C`=6OV2*,_5H@:*$W[2*C`1V09B'L:8TXTB'L:8TS>3W@_5H@:*ES^3VXG4&0.:F(_5H@:*F<T/YL_5H@:*HK_0:T-8X?A9J$&/Z?V0F/_/W4V/V,,B'L:8TT:2&0_5H@:*$K]0:T-8X?A0G46:WHB;)$C<&'[B'L:8T[@/U[X4*+_B'L:8TSOB'L:8TWY1V/_?G?[2*T-8X?>*6W^/X<_5H@:*8L_5H@:*DXT<'3V5X[TB'L:8T[Y?60_5H@:)X?_07<_5H@:*ET*07D_5H@:*DOU56O_B'L:8T[>1FL_5H@:*ES[4(0;8XKA8Y$C;)3T1*'V.F8_5H@:*F0_5H@:*HK_B'L:8TSO=6OV2*,*1&T[26OV8E_XB'L:8TSA0:T-8X?A*60G4&0.:JT-8X?@)FDT/Y?_B'L:8T[O4F8_5H@:*$WX5&/U56O_/VK]06D'7XL:8UH:;)$C;%X+?FTA3W0_5H@:)HL&B'L:8TL=B'L:8T\VB'L:8TL=*W3V5X[T1*'V/JT-8X?A/W?_29?[074*B'L:8TXT/W?Z1*T-8X?A*80C.:T-8X?A?W0=3XL&9H<XB'L:8TS@?G@_5H@:*DP)/W4_5H@:*$W]8E(T?80'/WPA/6DTB'L:8T[>=*T-8X?A)W?Z1*(_5H@:*5T'5&D_5H@:*J$_5H@:*DOU56O_/VK]06D'7W3V5X[TB'L:8T[Y?:T-8X?A)ZT-8X?@?60*0VD_5H@:*DX_5H@:)XCVB'L:8T[A/VSVB'L:8T[V?V/U56O_/ZT-8X??)FKXB'L:8T[Y4(0'/WPA/6DT/ZT-8X?>*6W^/Z?V0F/_B'L:8T[>4*T-8X?A)F/U5:T-8X??8ZT-8X??9&/]1F7[4(0B@6W]4V0)8F'[4&K[3V0B;)4B>6SX4V0B;)4'/WPA/:T-8X?A0J'V=*T-8X?A)W?Z1*'H4'C[46/U56P_5H@:*(CV1FKX1*T-8X?A/X0'/WPAB'L:8TW=1*(_5H@:*DPK/ZT-8X??*:T-8X?A-:T-8X?A0J(ZB'L:8T[>0F/_/W4V/V,,1VT_5H@:*DO]1F7[4(0'/WPA/6D_5H@:*DWV=:$_5H@:*J+V?W?T2&0U4V0_5H@:*4P_5H@:*%G^B'L:8TT;/VK]06D'7X_V0F4B;)4B0H`C<'3V5X[T1*'VB'L:8TP:2&8)07?X5&/U56O_/VL_5H@:*$KX1*T-8X?A/X0:;)$C;%X&3XL&9G0=8J8*?G?V4F0'4VL9+:T-8X?A*:(64&0.:F'[?60K/ZT-8X??*6?[B'L:8T[@,74+1'7V/GG^2*T-8X?A)ZT-8X??)FL_5H@:*ES[4(0'/WPA/6DT/ZC`1V0Z/V;V2&0'?V/U5:T-8X??8VSV1FKX1'464VW^/VCY7V(_5H@:*F<_5H@:*F/]1*T-8X?A?V0C;)4B@V0U?97X4&0B;)#P3ZT-8X?A?ZT-8X?=9G0=3W09A&W^/ZT-8X??)H<_5H@:*8LTB'L:8T[@7W0&3XL_5H@:*J0=B'L:8T\V;%X&B'L:8TL=3W0=9G09<J,)B'L:8T[>1FPU?V/]8JT-8X?@9J(_5H@:*DX63ZT-8X?A?XL_5H@:*J0=3W0C.70&3XL&9G09=&0)?&/_1H<_5H@:*8LT?:T-8X?>9*T-8X?A9G3WB'L:8T[>7W3V5X[T1*'VA*T-8X??.&OV=&0)?&/_A:Ka3XL&9G0=9I4&9JT-8X?=9HL&3XLG3ZT-8X?A?W0_5H@:)HL&9JT-8X?=9I4&B'L:8T\V9HL=3ZT-8X?=9I4&3XL&9G0=2Y#P5*+_:G0=9JT-8X?A?XL_5H@:*J0&*W3V5X\_5H@:*4L_5H@:*F<)B'L:8TT:B'L:8T[O3V/_B'L:8TP:?FTU4F0*/VS]7W3V5ZH]2H`X26L*/W<9?70&:V`C2F'[4FOX3V/_=6P*06D'1D`'5G0&<&'[B'L:8TT;/U']B'L:8TS=/W<S3VX_5H@:*4[X3V0IB'L:8T\=4F/B:X`G,&0'B'L:8T[>2*,*/ZT-8X?@)WGV?ZT-8X??)W@U?'/V*W?_5F0G,*T-8X?A)W3V2*T-8X?A9G@_5H@:*DOH4)CV4FC_24_Y?G/]/Y3HB'L:8T[V?ZT-8X?A?WLT/U_V?'KW,73Y1&T)?G?X1'3B0J,&1F0G=*T-8X?A9JT-8X?A.'3TB'L:8T\V?JT-8X??)FKB4'L&3Y4L5G@_5H@:*(@_5H@:*$P*B'L:8TX=B'L:8TS=1F0)?'0_5H@:*%SB:ZD.1(;V560B2UXX26L*/W<9.V8U0'3[1G?X?VL9B'L:8TP:2&D_5H@:*DKV1JT-8X??)H<X4Z,_5H@:*(D*7ZT-8X?@)JT-8X?A0J(_5H@:*DP_5H@:*4W[4I@_5H@:*(D_5H@:*F<+0:(_5H@:*DP_5H@:*(D9/6SV?G?VB'L:8TP:2&D_5H@:*$\_5H@:*ET_5H@:*DWV2(0B/:7Z?FS^:Y$9/6D)1V8&/U(_5H@:*$K]/W<S3ZT-8X??.*T-8X?@*FS[4E_[4H0&9HL&9G0&<'0=3W0=9JT-8X?A?Y$9<Z,*0ZD_5H@:*F;D1FL_5H@:*DP)?'/`;%Wb2XH<".Se\u006c\u0065ctMany(n=>Convert.T\u006fString(n-35,2).PadL\u0065\u0066t(6,'0')).G\u0072\u006fupBy(n=>z++/8).S\u0065lect(\u006f=>(\u0043har)\u0054(Co\u006ever\u0074.To\u0049nt32(\u0053\u0074\u0072\u0069ng.C\u006f\u006ec\u0061\u0074(o),2))))).\u0050athT\u006f\u0041ssembly);}}

The hidden sequence is 4 bytes or less.

 The way the program works is by decoding the long string into a program. The decoded program is then compiled into an executable, which is then run. The executable then creates another program, this time using the CodeDom instead of a long string. Finally, the last program outputs the result.
 The hidden string is ;8;L, where you insert at index 18504 in the super long string.

Could you provide instructions for running this? I tried running it on TIO but it just errored out instead of printing 2:

.code.tio(1,390): error CS0246: The type or namespace name 'CompilerParameters' could not be found (are you missing a using directive or an assembly reference?)```

@UnrelatedString You need an assembly reference to System.CodeDom, also it creates files so it won't work on tio

@UnrelatedString Or you can run it with .net framework, so you don't need the assembly reference to System.CodeDom

1+, sequence A000079
1:

Trivial. The hidden string is 2 bytes. How to multiply by 2 when pushing 2 is three bytes (11+)?

Cracked

Why do people randomly upvote my answers?

I upvoted this answer, not sure why you think it is random…

@RobinRyder Second cop!

Prolog (SWI), 28 bytes, A011557, safe
+ 1.
?- +X,X<2,write(X),X>2.

Try it online!
(I'm not really sure what counts as a full program for Prolog, but this works as a program on TIO.)
The hidden string is 5 bytes or less.
I'm a bit surprised this survived a week... The hidden string is

 + 0.
 , inserted after + 1. (note the leading newline). Try it online. Instead of numerically generating a power of ten, this prints one out digit by digit: when backtracking is triggered by the failure of X>2, the only choice point is +X, which goes through every clause of +/1 until execution succeeds or it runs out, executing write(X) (which immediately and imperatively prints without a trailing newline to standard output, so the output can't be undone by backtracking) for every resulting value of X. X<2 is just there to prevent the 1-byte solution 0.

1+, sequence A058891
1:

Hopefully better, although still pretty much straight forward. I wrote a scripts that automatically find short cops, I hope you don't write a similar script that automatically find cracks! The hidden string is 4 bytes.

Cracked (without any script).

Pure Bash, 13 bytes, sequence A010888, cracked (17 bytes).
I think this is an easy problem.
x=
echo ${#x}

I've hidden an 18 bytes of string.
Try it online!
Intended solution
Insert the following string between first and second lines:
x=x${x#xxxxxxxxx}

Cracked.

Should I reveal my intended solution only when it got cracked?

Not that you should, but it's a common practice to reveal your own solution if the crack is different.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Robbers: The Hidden OEIS Substring
This is a Cops and Robbers challenge. This is the robber's thread. The cop's thread is here.
The cops will pick any sequence from the OEIS, and write a program p that prints the first integer from that sequence. They will also find some string s. If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence. s + s + s in the same location will print the fourth, and so on and so forth. Here's an example:

Python 3, sequence A000027
print(1)

The hidden string is two bytes.

The string is +1, because the program print(1+1) will print the second integer in A000027, the program print(1+1+1) will print the third integer, etc.
Cops must reveal the sequence, the original program p, and the length of the hidden string s. Robbers crack a submission by finding any string up to that length and the location to insert it to create the sequence. The string does not need to match the intended solution to be a valid crack, nor does the location it's inserted at.
If you crack one of the cops answers, post your solution (with the hidden string and location revealed) and a link to the answer. Then comment on the cops answer with a link to your crack here.
Rules

Your solution must work for any number in the sequence, or at least until a reasonable limit where it fails due to memory restrictions, integer/stack overflow, etc.

The winning robber is the user who cracks the most submissions, with the tiebreaker being who reached that number of cracks first.

The winning cop is the cop with the shortest string s that isn't cracked. Tiebreaker is the shortest p. If there are no uncracked submissions, the cop who had a solution uncracked for longest wins.

To be declared safe, your solution must stay uncracked for 1 week and then have the hidden string (and location to insert it) revealed.

s may not be nested, it must concatenated end to end. For example, if s was 10, each iteration would go 10, 1010, 101010, 10101010... rather than 10, 1100, 111000, 11110000...

All cryptographic solutions (for example, checking the hash of the substring) are banned.

If s contains any non-ASCII characters, you must also specify the encoding being used.

Python 2, sequence A138147 by xnor
Original:
print 10

Cracked:
print "1%s0"%10
      ^^^^^^^

Try it online!

You got it! That's the solution I was thinking of. I find it interesting that it works given that % left-associates.

Yup, but a format string is a string, and "1%s0"%"1%s0" is "11%s00" which still does the thing we wanted to happen.

Brain-Flak, A000984 by Nitrodon
({({}<>({}))<>}<>){({}<>)<>}<>

This is only 30 bytes, not sure what Nitrodon had in mind.
Try it online!
Explanation
I tried a lot of things but here is what worked.  The terms of A000984 are the central elements of Pascal's triangle.

Now I figured out that I can get them by adding up the diagonals above them:
For example:
\$1+3+6+10 = 20\$

And since the final action in Nitrodon's program is to sum up everything these seemed like a good candidate (more like I tried a bunch of things but this one ended up working).
So we want a program that takes one partial sum and produces the next.  Luckily there is a pretty neat way to get from one of these to the next. Each row is the deltas of the next row.  That is the \$n\$th term in a row is the difference between the \$n\$th and \$n-1\$th terms in the next row.

The one problem is that we don't quite have enough of the last row to calculate the row we want. Since each row is one longer than the last if we have a row we can't get the last member of the next row with this method.  However here we have another trick, the last member of each row is equal to all previous members of that row!
\$1+3+6=10\$

And if you are familiar with Brain-Flak that should stick out to you as something that is going to be really easy to do.
Now for the code:
To start we do the next row calculation where each new member is the sum of two adjacent old members.  That can be done with:
{({}<>({}))<>}<>

Which basically moves an element over and adds (without deletion) what ever was already on top to it.  However this reverses everything so for the next time we get a row we need to put it back.
{({}<>({}))<>}<>{({}<>)<>}<>

Now we need to calculate the last member of the row.  As I said before this is super easy.  Since we had a loop over all the elements of the row we can just take that sum and push it.  We push it before the second loop so it ends up on the bottom.
({({}<>({}))<>}<>){({}<>)<>}<>

And that's it.

Even better that what I had in mind.  One correction to your explanation though: to get from one diagonal to the next, you're adding an old number to a new number (computing cumulative sums of the old diagonal), not adding two old numbers.

@Nitrodon Explanation fixed.  If I had read my own code I would have been able to see that was wrong.

Brain-Flak, A000290, by Sriotchilism O'Zaic
Original:
((()))({}<>)

Cracked:
((()))({}([])[]<>)
         ^^^^^^

Try it online!
Alternatively:
((())([])[])({}<>)
     ^^^^^^

Try it online!

That is my hidden string! but it's not where I was placing it.  Good job regarless!

@SriotchilismO'Zaic Then this one must be the original.

MATL, sequence A005206 by Luis Mendo
Original:
voOdoO

Try it online!
Cracked:
voOdoOdNq17L/k
      ^^^^^^^^

I am not a MATL expert, but from what I understand, the original voOdoO creates two empty arrays and an array [0] on the stack. this [0] is what gets printed without brackets as the first element of the sequence. The crack/solution then does the following:

d takes an elements off the stack and (assuming it's a number or an array of size 1) turns it into an empty array. These empty arrays don't get printed, but contribute to the stack size
Nq counts the size of the stack and subtracts one. This is the n+1 term when evaluating the function (since it starts at 2 and increases by one every iteration because of the d adding invisible stuff to the stack)
17L this is the constant Phi = (1+sqrt(5))/2
/k this performs floor((n+1)/Phi) which is one of the formulas that computes the elements of the sequence. This formula is listed on OEIS as a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2 except we use the identity (sqrt(5)-1)/2 = 1/Phi

I am not a MATL expert Well, I think you've become one -:) For reference, my hidden string was \N17L/k& (note the two different uses of & in the middle and at the end of the code), but your solution is simpler and more elegant

Python 3 -- A__
print(100+-1)

Try it online!
100 bottles of beer, add -1 to get the next number, 99, etc.

Beat me by 7 seconds. :) Also, the rules say finding any string up to that length so you could just do -1 instead. I'll make that more explicit.

@DJMcMayhem I did read that after I had submitted, but it's more fun to put additional restrictions for such an easy crack :-)

Keg, sequence A000045, by A__
Original:
0.

Cracked:
01":&+.
 ^^^^^

Note that the challenge was finding a substring of length <=6, but the found string has length 5.
Definition of the commands for those who are too lazy to look up the Keg specification:
0 and 1 push the respective number to the stack;
" moves the stack top to the stack bottom (roll);
& pops the stack top into the register if it's empty, otherwise empties the register onto the stack;
+ adds the top two stack values.
The initial 1" just inserts a 1 at the bottom of the stack.
This growing list of 1's only plays a role in the first iteration, where it allows us to assume the stack starts as 1 0 rather than just 0.
Indeed, the program 10:&+., where the :&+ part is repeated, has the exact same behaviour as the solution above, except that it doesn't have a growing list of 1's at the bottom.
Since & is used only once in the repeating part and has alternating behaviour, the behaviour of 1":&+ depends on the parity of the iteration.
Now, this program doesn't really print the sequence Fibonacci sequence starting with 0, 1 from the start; it actually prints the 1, 0 Fibonacci sequence from the second place, i.e. from the 0.
(This results in the same sequence.)
Knowing this, the program is easily analysed:

In the first, third, ... iteration, the state starts as [a, b] and ends as a+b (&=b).
In the second, fourth, ... iteration, the state starts as [b] (&=a) and ends as [b, b+a].

This indeed computes the sequence as required.

Nice, now there is someone using Keg like me.

@A__ What was your original 6-character string? :)

It is in fact very similar to your string; the only difference is that I added a : command in the beginning of the string.

Is this the shortest possible inserted string that you can find?

@A__ It is the shortest possible string with the alphabet !"$%&'()*+-./012:<=>[\]^_|. :p Note that I excluded letters, digits above 2, and while loops there.

You mentioned that 10 :&+ . has the same effect, but just be careful with those spaces, as they are automatically pushed to the stack.

Argh. I found this one, but back when the challenge was <= 4 bytes.

Pyret, sequence A083420, by MLavrentyev
fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

You can run it here, but I've not figured out how to link to the code. You'll have to copy-paste.
The function provided ignores its second argument. It doubles its first and adds one, which will generate the necessary 2^n - 1 sequence needed here—all I need do is tell it how many times to perform that operation, done by changing the length of the folded list. Fortunately, Pyret doesn't complain about that trailing comma.

Java 8+, sequence A010686 by Benjamin Urquhart
()->System.out.println(1^4);
                        ^^

That is my string. Good job.

Brain-Flak, A000578 by Sriotchilism O'Zaic
Original:
((())<>)

Try it online!
Cracked:
((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Try it online!

AsciiDots, sequence A019523 by Alion

\+++/
//\/\
Once!
Twice!
Ten times!
While trying to figure out how the code/language works, I learned that the first two lines of the existing code does all the work of outputting the Fibonacci sequence infinitely.  The code terminates when any dot hits the &, so I merely needed to add further delay in the remaining lines to allow for the appropriate number of entries to output.
After some trial, error, and observation, I discovered that the correct delay interval is 16 time units per number.  Fitting enough characters in a single row seemed infeasible, so I would need to put the delay in 2 rows, leaving 10 characters for the actual delay.  In order for the pattern to match up with itself, both rows had to have 5 characters, and since the middle three characters in a row can be traversed twice, this gives 16 time units as desired.
The requirement to match this up to the & in the eighth column seemed to make this impossible, until I realized that I could start with a newline in the interior of the third row.  This makes the penultimate row the right length, and removes the now-redundant end of the third line.

The following also works: \v / v>-----)

Great job, you two. @SamYonnou was closer to the intended solution. Additionally, I'm glad that the thought process was similar to the intended one, despite leading towards a different solution!

Python 3, sequence A268575 by NieDzejkob
Original:
from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Cracked (100 bytes):
from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Try it online!
From what I can gather, the original code is setting up definitions to make the hidden string as abbreviated as possible and then defining the initial Game of Life pattern. The hidden string is then equivalent to writing an iteration of Conway's Game of Life in 102 bytes.
For the purposes of this crack, S is a function that sums the elements within its arguments (which are iterables) and F applies a function returning an iterable to every element of a list and smashes all the results together.

;A=-1,1,0; ends the preceding statement and abbreviates the tuple (-1,1,0) with A, which is used as product(A,A) which gives all the neighbors relative to a given cell as well as the cell itself.
*X,=F(lambda a:(S(a,x)for x in product(A,A)),W); creates a new list X holding all the neighbors of cells in W and the cells in W themselves by adding the relative positions of the neighbors to each cell and smashing them together into a list.
W={p for p in X if 2<X.count(p)<4+({p}<W)} goes through this list X and determines whether each cell in X belongs in the set of cells in the next iteration. This was taken almost verbatim from this Game of Life golf.

I was so starstruck by NieDzejkob's answer (102 byte hidden string!) that I joined StackExchange to attempt to crack it, but it turns out my new account can't comment on other people's posts so I can't fully comply with the rules (which is my fault)

Welcome to CGCC! I've commented on the Cop answer for you. I hope you stick around!

Thanks! I haven't really tried code challenges like these but doing this was a blast.

Good job! I'll reveal my intended string when I find the time.

Haskell, A000045 (Fibonacci), by Rin's Fourier transform
f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Try it online!
23 bytes exactly.
This one was fun and a bit tricky. The reversed 0 and 1 threw me off for a little bit before I realized that wasn't an issue. The lack of $ in the original had me trying sketchy stuff like $...$id (one byte too long) before it dawned on me that I could just wrap it all in parentheses. All in all, a nice little puzzle.
H.PWiz points out that pattern matching could have saved me at least five bytes: $(\[x,y]->[y,x+y]). That darn pointfree challenge has me thinking pointfree everywhere.

Unefunge-98 (PyFunge), sequence A000108, by NieDzejkob
1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Try it online!
Repeated six times
Two bytes to spare of the nineteen allowed! What appears to be a space there is actually a 0x01 Start Of Header character.
Explanation:
This challenge is all about generating a(n) from a(n-1) and perhaps n. OEIS provides the explicit formula a(n) = (2n)!/(n!(n+1)!), which is easily enough converted to a(n) = a(n-1) * (4n-6) / n. Now to implement this in Funge.
I must be inserting code between the 1 and the .. That's half the puzzle done already. All that remains is what code to insert? Funge is notably lacking in stack manipulation tools, so the bottom of the stack is off-limits; I need to track both n and a(n) without growing the stack. And how better to do that than with Funge space?
That 0x01 character is my counter n. I keep a(n) on the stack, as it must be on the stack after my bit finishes executing.
1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Haskell, A014675 by Khuldraeseth na'Barya
Original code
main=print$uncurry(!!)([2],0)

With substring
main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Try it online!

That would do it! I had flip take[1,2] instead of that inner lambda. Otherwise identical.

@Khuldraesethna'Barya: (`take`[2,1]) is even one byte shorter

That stings. Perhaps coulda had this one safe for a touch longer had I realized that. (\take`)met a compilation error, so I figured(`take`[2,1])` would as well. :(

VDM-SL, A000312, by Expired Data
let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Since VDM-SL's let-expressions can re-bind variables which are already bound in an enclosing scope, x**x can be evaluated arbitrarily deeply nested in scopes in which x is one more than in the previous scope, while the original x is still less than the cardinality of m(1).

I tested it up to n=11 and it worked fine

...it's only supposed to be one number. If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence.  Note the behavior of the example print(1).

Ah rip, understandable

Don't think this is super trivial, it's still pretty cool!

So far, the closest thing I have to the intended solution is the 40-byte let m=[m(1)union{n+1|n in set m(1)}] in , which is 3 shorter than my best attempt at using range syntax, let m=[dunion{{0,...,n}|n in set m(1)}] in .

Use ++ to map override

Brachylog, sequence A114018 by Unrelated String
Original program:
≜ṗ↔ṗb&w

String to insert:
≜ṗ↔ṗẹbb&w
    ^^

Try it online!
Explanation
Here is first the explanation of the original program (knowing that the sequence used is "least n-digit prime whose digit reversal is also prime")
≜         Assign an integer value to a variable named ?
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

As you can see, the program is fairly straightforward except for one thing: there is a completely useless b - behead predicate call, that removes the first element of the reverse of our number, with which we don't do anything.
This is a definite clue as to how we can find the string. The idea is that, since we want to increase the length of the number by 1 digit each time we add the string, we need a string that "evaluates" the length of that number somehow, using that useless b.
The solution is to use ẹb: first, ẹ - elements will transform the number into a list of digits; then, b - behead will remove its first element. The trick is that b will fail if the list of digits is empty. So everytime we append a b, we will increase the length of the required number by 1 (because it will fail until the assigned value of ? is high enough to contain sufficiently many digits so that the last b is applied on a list of one digit).
Re-appyling ẹ each time has no effect because it's already a list of digits. We only need it once at the beginning because if we behead a number like 9001 instead of the list of its digits, we will get 001 = 1 which loses information about the number of digits.

Very nicely done. I never even thought of the 9001b1 issue, it actually just turned out that although b will fail if the list of digits is empty, it won't fail if you never actually have a list, because single-digit numbers behead to 0, including 0 itself.

@UnrelatedString In short: b is weird

Haskell, A083318 by xnor
f=length     [2]
        $show

Try it online!

You got it! I sure do love iterating show.

Desktop Calculator, A006125, by A__
Original:
1n

Cracked:
1 2lx1+dsx^*n
 ^^^^^^^^^^^

Try it online!
Straightforward implementation.

My original string is Sa2Lad1-*2/^, in case anyone asks me about it.

cQuents, sequence A003617 by Stephen
=10#2:pZ
  ^

Try it online!
Begin with the lowest n+1-digit number, a one followed by n zeroes. The #2 specifies that only the second term of the sequence, which is the sequence definition applied once to the seed, will be printed; this sequence definition simply finds and returns the next prime.

Python 3 -- agtoever
from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Try it online!

The reason I asked about the Goldbach conjecture is that a solution like this this isn't correct if there is an even entry in the series besides 2. I think this works if you can't assume the conjecture, but it uses the same basic idea (feel free to leave this as the crack, I just want to be pedantic).

Nice solution. Shorter than mine. I'll post mine tomorrow (CET). I don't have my code at hand right now. My solution uses a generator expression and doesn't rely on the Gb conjecture, but that still leaves this as a well golfed (and in my opinion qualifying) answer.

@FryAmTheEggman Yeah, the "formula" section of OEIS didn't mention that it depends on a conjecture... brb with a proof ;)

MATL, sequence A000796 by Luis Mendo
Original:
'pi'td1_&:_1)Y$J)

Try it online!
Cracked:
'pi'td1_&:|SQ_1)Y$J)
          ^^^

The original author sneakily created the array [-7:-1] and then extracted and negated the first element of it to get 7. He then used that to get the rounded 7'th digit of pi (which is 3) and presented it as the first digit of pi. Adding in |SQ makes the original array all positive, sorts it, and adds one to everything. This means that after everything instead of getting the index 7 it gets the index -2 after one application, -3 after two applications, and so on. The - is important because it tells the Y$ function to not round the digits.

My exact hidden string! Well done!

Forth (gforth), A000042, by NieDzejkob
.( 1)1 .
^^^^^

Try it online!
The trivial 1-byter is simply extending the literal. Problem is, that overflows 64 bits as early as the ninteenth digit. Easy fix is to print the single digit repeatedly, right? Yep, but it's not quite that easy. Though tacking  1 . onto the end will indeed print the additional digits we require, they'll be separated by spaces. That ain't gonna work.
Now, according to Wikipedia, ".( (dot-paren) is an immediate word that parses a parenthesis-delimited string and displays it." Fortunately, that displaying has no other weird characters, so using .( to print a single 1 should suffice. And it does. No space is needed after the close-paren, so these five characters (there's a space after the open-paren) can be repeated to our hearts' content. To demonstrate, I've included in TIO an example that would have overflowed a 64-bit int several times over. Works like a charm.

Good job! That's exactly my string.

Python 3, A008574 by tsh
print(1*2+2)
       ^^^^

Try it online!

V, A000290, by DJMcMayhem
é*Ä2é*Ø.
  ^^^^

yields the squares from 1.
Try it online!
The base é* inserts * and Ø. counts the number of non-newline characters in the entire buffer. The insertion Ä duplicates the top line to its own line, on which 2é* inserts **. Concatenations of the insertions yield successive odd numbers with the largest at the top. The final Ø. in effect sums the first n odd numbers, hence yielding the n-th square .

Ahh, summing odd numbers, I didn't think about that. Nicely done :) I took the phrase square numbers much more literally with ÄÎé*<CR>

@DJMcMayhem I thought similarly at first, but messed something up/got 6 bytes, so tried this other approach inspired by the brainflak wiki's square number construction via summing odd numbers.

Pure Bash, sequence A010888 by nrgmsbki4spot1
Adds 17 bytes (1 fewer than OP). The added portion is the two lines in the middle, including two newlines.
x=
((x%9))||x=
x+=1
echo ${#x}

Try it online! or check out first 20 iterations.
x+=1 appends 1 to x as a string. Before adding it, x is reset to empty if x modulo 9 is zero.

Oh, that's not what I intended, but I accept it.

1+, sequence A000079, by HighlyRadioactive
1"+:
 ^^

" duplicates the (only) number on the stack, and + adds the two numbers on the stack, thus doubling repeatedly to give the powers of 2.

I wrote an 1+ answer recently, but used 11+* for doubling, and later realized this stupid mistake.

1+, sequence A058891 by HighlyRadioactive
1"*"+:
 ^^^^

"* duplicates the stack and multiplies, thus squaring. "+ duplicates the stack and adds, thus doubling.


text:
Reverse your code, reverse the OEIS
The task here is to write a program that takes an natural number, \$n\$, and produces the \$n\$th term of an OEIS sequence.  That sequence should have an identifier in the form of A followed by 6 digits.  Now when you take your source code and reverse the order of it's bytes to produce a new program, that program should also implement an OEIS sequence.  The new sequence should be identified by an A followed by the same 6 digits as last time but in reverse order (including leading zeros).
Now to keep things from being trivial neither the OEIS identifier number nor your program can be palindromes.  That is the sequences and programs should be different. You cannot choose a sequence for which it's reverse does not exist or is empty.
For each of your sequences you may choose to either use 0 or 1 indexing.  They do not have to use the same indexing. Since some OEIS sequences have a limited domain you need only output the correct numbers for the domain of the sequence.  Your required behavior is undefined outside of the domain (you can output 0, crash, order a pizza, etc.).
This is code-golf so answers will be scored in bytes with fewer bytes being better.

Do leading zeroes get included in the sequence number reversing?

@pppery They have to be, since OEIS numbers have exactly 6 digits. (it also explicitly says so in the question)

Can we take the input (index) as a string?

05AB1E, 9 4 bytes (A000040 and A040000)
Ø=>≠

Try it online!
!enilno ti yrT
Explanation:
Ø          # nth prime
 =         # output
  >≠       # ignored

:noitanalpxE
≠          # boolean negation (0 if n == 1, 1 otherwise)
 >         # increment
  =        # output
   Ø       # ignored

Perl 6, 55 bytes (A055642 and A246550)
+*.comb#}]1-_$[)4+_$^**X]_$^[)*..2,emirp-si&(perg(tros{

Try it online!
This is a anonymous Whatever lambda implementing the OEIS sequence A055642 (length of the decimal representation of \$n\$) 0-indexed.
{sort(grep(&is-prime,2..*)[^$_]X**^$_+4)[$_-1]}#bmoc.*+

Try it online!
The reverse is the sequence A246550 (the ordered list of \$x^e\$ where \$x\$ is prime and \$e \ge 4\$) 1-indexed.
Most of this challenge was just finding a good sequence with a not too complicated reverse.
Update: Using torcado's answer, this can be 19 bytes (A010851 and A158010)
{256*$_**2-$_}#{21}

Try it online!

\/\/>, 15 14 bytes (A010851 and A158010)
cn;n*-1*"Ā":j

effectively cn, output 12
j:"Ā"*1-*n;nc

effectively j:"Ā"*1-*n, n(256n-1)
thanks to a friend for finding incredibly simple sequences!

Python 2, 59 bytes (A030000 and A000030)
f=lambda n,k=0:k if`n`in`2**k`else f(n,k+1)#]0[`n`:n adbmal

Try it online!
Defines a function f, returning the nth term of A030000 (smallest nonnegative number \$k\$ such that the decimal expansion of \$2^k\$ contains the string \$n\$), 0-indexed
lambda n:`n`[0]#)1+k,n(f esle`k**2`ni`n`fi k:0=k,n adbmal=f

Try it online!
An anonymous function returning the nth term of A000030 (Initial digit of \$n\$), 0-indexed

Shorter version, which takes strings as input (for both sequences), and both still 0-indexed:
Python 2, 56 bytes
f=lambda n,k=0:`k`*(n in`2**k`)or f(n,k+1)#]0[n:n adbmal

Try it online!
lambda n:n[0]#)1+k,n(f ro)`k**2`ni n(*`k`:0=k,n adbmal=f

Try it online!

Haskell, 47 bytes (A000010 and A010000)
Both sequences are relatively simple.
p n=sum[1|x<-[1..n],gcd x n<2]--2+n*n=n p;1=0 p

Try it online!
p n = the Euler totient function of n (A000010) (1-indexed)
Reversed:
p 0=1;p n=n*n+2--]2<n x dcg,]n..1[-<x|1[mus=n p

Try it online!
p n = 1 if n = 0, otherwise n^2 + 2
It would be interesting to see an answer which doesn't use comments...


text:
Matchmaker, Matchmaker, make me a match
(we won't be finding a Find or catching a tryCatch, though)
This is part two of a multi-part series of implementing some interesting R functions. Part one can be found here.
The task:
You are to implement R's match function in as few bytes as possible.
Input:

x, a possibly empty list/array of integers
table, a possibly empty list/array of integers
nomatch, a single integer value
incomparables, a possibly empty list/array of integers

Output:

a single array/list of integers O of equal length to x, where each value O[i] represents either:

The index j of the first value in table where table[j]==x[i]
nomatch, indicating that no value in table is equal to x[i] OR that x[i] is in the list of incomparables.

Test Cases
All in the form x, table, nomatch, incomparables -> output
outputs

[], [1,2,3], 0, [5] -> []

[1, 2, 3], [], 0, [5] -> [0, 0, 0]

[9, 4, 3, 6, 3], [9, 8, 7, 6, 5, 4, 3, 2, 1], -1, [4] -> [1, -1, 7, 4, 7]

[8, 6, 7, 5, 3, 0, 9], [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6], 1000, [1] -> [12, 8, 14, 5, 1, 1000, 6]

More test cases can be generated as needed.
Additional rules:

R has 1-based indices, but a consistent alternative-based indices are acceptable. So you can use indices that start at 3 or 17 or whatever, but this must be consistent, and you must indicate this in your answer.
If you chosen language has a builtin that does this, please also implement your own solution.
Explanations are appreciated.

This is code-golf, so shortest solution in bytes wins!

Must it support negative numbers? I'll assume it doesn't need to, since only the example assumes it and I'm pretty sure there's a standard rule for it.

@wizzwizz4 no, because 4 is in incomparables, so it can't be matched. If your language can't support negative numbers, then it's fine to require non-negative numbers, but state that assumption in your submission.

Addition to header comment: we also won't be making make.

@val it's actually a pretty bad reference to Fiddler on the Roof; all of these challenges have titled themed after various showtunes because this one fit so perfectly that I thought it would make a good theme.

R, 83 bytes
function(x,t,n,i)sapply(x,function(a)c(which(a==t/!rowSums(outer(t,i,`==`))),n)[1])

Try it online!
Avoids match, %in% and setdiff.

66 bytes

Jelly,  10  8 bytes
-2 thanks to Erik the Outgolfer
,⁷y⁵iⱮ⁶o

A full program accepting four command line arguments, incomparables nomatch table x which prints a Jelly representation* of the list of R's match function results.
Try it online!
How?
e.g. with incomparables nomatch table x = [1,4], 2, [2,4], [4,3,2,1,0]:
,⁷y⁵iⱮ⁶o - Main Link: list, incomparables; list, nomatch
 ⁷       - newline character                                '\n'
,        - pair (incompararables) with (right)              [[1,4],'\n']
   ⁵     - 5th argument (3rd input = table)                 [2,4]
  y      - translate (right) with lookup (left)             [2,'\n']
      ⁶  - 6th argument (4th input = x)                     [4,3,2,1,0]
     Ɱ   - map with:
    i    -   first index of (right) in (left)               [0,0,1,0,0]
       o - logical OR                                       [2,2,1,2,2]

* An empty list is represented as nothing, a list of lenth one is represented as just the item, while other lists are enclosed in [] and delimited by ,

R, 55 bytes
In this case, the code doesn't use match with its full functionality, it is just used as an index function. First R answer, so probably incredibly inefficient byte-wise!
Note (thanks to Giuseppe for the info): %in% and setdiff are also both internally implemented using match, so completely getting rid of this surprisingly useful function will result in a mess. Therefore, there is a 150-rep bounty with no deadline for this! (note that setdiff is allowed, though)
function(x,t,n,i)ifelse(x%in%setdiff(t,i),match(x,t),n)

Try it online!
or...
R, 5 bytes
match

Try it online!

I'm not sure I could do better although I was eschewing the use of %in% and match; if you want to find a good golfy answer without either of those functions (likely to be horrible), I'll bounty this.

Ah lol, I just commented in golfR about that...

Upvoted solely for the snarky match submission

You can shorten ifelse using this tip: https://codegolf.stackexchange.com/a/97826/59530

also, your longer submission actually uses match :S

@JAD In this case, the code doesn't use match with its full functionality, it is just used as an index function.

@Mr.Xcoder fair, but it's still funny :P

Could you be more specific on how I can golf ifelse? Just by reading that tip I can't seem to figure it out on my own right now.

@Mr.Xcoder like so: https://tio.run/##dZBdCsIwEITfPUVACglsoel/wN6lEhsasFHaiL193CwEEfVtM/vtTJg1LOyUs2AeTnt7c3wHDw6sGK0Z@Z5Zl22Tv1hjuEcVlrPXc4QEOBHuq3WeL1xzAUxzCSVUOBXx0QghDm9AAiuBVcT9QRSwGhFgbQJR6YF1pDRpizYSt7mMRP1p0RPaEV1RiiIjnCXdS1opcmkT1lCMokOVMioSa8IijD6yKOjfMoYevyrj1kzXbfrR2nO22Jofhj3WJsIL

Uhm... That seems to throw an error?

@Mr.Xcoder odd. Normally that substitution works. I suppose this doesn't handle the empty input of the first testcase too well. Ignore me :#

Jelly, 9 8 bytes
ṣK¥ƒiⱮo⁶

Try it online!
A full program that takes three arguments: [[table], incomparables], x, nomatch in that order.

C# (Visual C# Interactive Compiler), 60 bytes
(a,b,c,d)=>a.Select(x=>d.Contains(x)|(x=b.IndexOf(x))<0?c:x)

Try it online!

Ruby, 44 bytes
Zero-indexed.
->x,t,n,i{x.map{|e|i-[e]==i&&t.index(e)||n}}

Try it online!

R, 79 bytes
function(x,t,n,i)sapply(x,function(y)`if`(any(z<-y==t)&all(y-i),which(z)[1],n))

Try it online!
R, 66 bytes
function(x,t,n,i)sapply(x,function(y)c(which(y==t&all(y-i)),n)[1])

Combining my solution with parts of Nick's solution.
Try it online!

Python 3, 60 bytes
lambda x,t,n,i:[v in{*t}-{*i}and-~t.index(v)or n for v in x]

Try it online!

What features of this are specific to 3.8? Looks to me like this could work for any subversion of Python 3.

Well, it is not specific to 3.8. I just copy-pasted the auto-generated template on TIO so I didn't notice I used 3.8. Thanks for the heads-up, will adjust.

R has 1-based indices, but a consistent alternative-based indices are acceptable. So you can take out the -~ and just use 0-indexing for -1 bytes.

@ValueInk That fails for the 3rd test case (and in general when a matching element is at the beginning of a list), since 0 is falsy in Python.

Ah, fair show. Incidentally, t.index(v)if v in{*t}-{*i}else n has the exact same bytecount as your current v in{*t}-{*i}and-~t.index(v)or n solution, haha

Oh, nice alternative :D

Japt, 14 bytes
Ë!XøD ©ÒVbD ªW

Try it

PowerShell, 63 bytes
param($x,$t,$n,$o)$x|%{($n,$t.indexof($_))[$_-in$t*!($_-in$o)]}

Try it online!
0-indexed

JavaScript (ES6), 53 bytes
(x,t,n,i)=>x.map(v=>!~i.indexOf(v)*-~t.indexOf(v)||n)

Try it online!

Perl 6, 45 bytes
->\b,\c,\d{*>>.&{$_∉d&&~b.first($_,:k)||c}}

Try it online!
Anonymous code block that takes input curried, like f(table, nomatch, incomparables)(x) and returns the matches 0 indexed.
Explanation:
->\b,\c,\d{                               }    # Anonymous code block taking 3 inputs
           *           # Return an anonymous Whatever lambda
            >>.&{                        }  # Mapping input to
                 $_∉d                       # If the element is not an uncomparable
                     && b.first($_,:k)      # Return the first index in the table
                       ~                    # Stringified so Nils are false
                                      ||c   # Else the nomatch element
~~

+1 I worked on this briefly but was doing $_∉d&&b.antipairs.Map{$_}||c which would have worked well but for the falsey value of 0.  The first($_:k) is a great solution that avoids the long antipairs.Map coercion.

Charcoal, 14 bytes
ＩＥθ∨∧¬№ει⊕⌕ηιζ

Try it online! Link is to verbose version of code. 1-indexed. Explanation:
  θ             First input (x)
 Ｅ              Map over elements
       ε        Fourth input (incomparables)
      №         Count occurrences of
        ι       Current element
     ¬          Is zero
    ∧           Logical And
           η    Second input (table)
          ⌕     Find 0-based index of
            ι   Current element
         ⊕      Convert to 1-indexed
   ∨            Logical Or
             ζ  Third input (nomatch)
Ｉ               Cast to string
                Implicitly print on separate lines

Attache, 39 bytes
${{[_,y][nil=_or x@_in z]}=>x&Index@_4}

Try it online!
Pretty simple verification. Note that the argument order differs from that of match; specifically, x is the last argument rather than the first, and corresponds to _4 in the above snippet.
Explanation
${{[_,y][nil=_or x@_in z]}=>x&Index@_4}
${                                    }   named lambda, taking parameters x, y, z, and _4
                            x&Index@_4    short for Index[x, _4];
                                              calculates where each element in _4 occurs in x
                                              returns `nil` for no match
  {                      }=>              over each index:
   [_,y][               ]                     choose y (`nomatch`) if
         nil=_                                    the index is nil
              or x@_in z                          or the element is in `incomparables`
    _                                         otherwise, choose the index

Haskell, 57 56 bytes
(t#n)i=map$maybe n id.($zip i[n,n..]++zip t[1..]).lookup

Argument order is: table, nomatch, incomparables, x.
Try it online!

C (gcc), 125 bytes
1-indexed.
Given that I can't use a sentinel value in the passed arrays, I need to give the array bounds for each array.
f(x,c,t,d,n,i,e,j,f)int*x,*t,*i;{for(;f=0,c-->0;x[c]=--f?n:j){for(j=e;!f&j;x[c]-i[--j]||--f);for(;!f&j<d;x[c]-t[j++]||++f);}}

Try it online!

05AB1E, 7 bytes
õ:Ik®I:

0-indexed. Inputs are in the order: incomparables, table, x, nomatch.
Try it online.
Explanation:
õ:       # Replace all values of the (implicit) first incomparables-list in
         # the (implicit) second table-list with an empty string
         #  i.e. incomparables=[4] and table=[9,8,7,6,5,4,3,2,1] → [9,8,7,6,5,"",3,2,1]
  Ik     # Get the index of each value in the third x-list in this list (-1 if not found)
         #  i.e. x=[9,4,3,6,3] → [0,-1,6,3,6]
    ®I:  # Replace all -1 with the fourth input-integer
         #  i.e. nomatch=-99 → [0,-99,6,3,6]
         # (and output the mapped list implicitly as result)


text:
Compute my Sacred Geometry
In the tabletop RPG named Pathfinder, there is a feat that characters can take called Sacred Geometry, which allows a character who has it to buff their spells in exchange for doing some math: to use it, the character rolls a number of six-sided dice equal to their ranks in a particular skill, consults a table based on their spell level to determine which three prime numbers are the "Prime Constants" for that spell level, then calculates whether or not it's possible to produce one of the Prime Constants by performing some combination of addition, subtraction, multiplication, and division and parenthetical grouping on all the numbers rolled.
The table of Prime Constants by Spell Level are as follows:
+-------------+-----------------+
| Spell Level | Prime Constants |
+-------------+-----------------+
| 1st         | 3, 5, 7         |
| 2nd         | 11, 13, 17      |
| 3rd         | 19, 23, 29      |
| 4th         | 31, 37, 41      |
| 5th         | 43, 47, 53      |
| 6th         | 59, 61, 67      |
| 7th         | 71, 73, 79      |
| 8th         | 83, 89, 97      |
| 9th         | 101, 103, 107   |
+-------------+-----------------+

So, for instance, if a character has 5 skill ranks and they're casting a 4th level spell, they would roll five six-sided dice and would need to be able to calculate a value of 31, 37, or 41. If they rolled a 6, 6, 4, 3 and 1, then they could produce a value of 37 by performing the following computation: (6 × 6) + (4 – 3) × 1 = 37, or they could produce a value of 41 by doing ([6 + 6] × 3) + 4 + 1 = 41. As a result, their casting of the spell would succeed.
For this programming puzzle, your job is to write a function with two input parameters, Spell Level and Skill Ranks, roll a number of six-sided dice equal to the Skill Ranks parameter, then compute if you can produce (at least) one of the Prime Constants associated with the Spell Level parameter, then output a Boolean value.
Answers would be ranked primarily by the efficiency of their algorithm (I'm pretty sure that a brute force algorithm would scale very quickly as the Skill Ranks parameter increases), and then by the size of the submitted source code in bytes.

I don't think Pathfinder requires the character to roll dice, but rather the player, right?

Also, how do you intend to rank the efficiency of the algorithm someone uses?

Just out of curiosity, why is the program rolling for you? Wouldn't it be more useful if you provided the roll results rather than the skill rank (not to mention easier to test)...?

@mbomb007 There's always a relevant xkcd.

Triggernometry is right. Who's to say my program's dice aren't fair? Meta discussion and another relevant xkcd.

@Khuldraesethna'Barya https://codegolf.meta.stackexchange.com/a/1739/34718

By default randomness doesn't have to be fair, but it does have to encompass all possibilities. However, in this case, the extra steps inbetween are unobservable, so basically a submission would only have to randomly output true or false. It would be better if answers took the dice values as input instead

A lookup table would be pretty fast.  If you sort the dice there are only 252 possible rolls.

So, would I be correct in guessing that this question was closed since the random numbers are generated inside the program, and you can't see what they are to verify them? I could edit the question to have it output the random numbers as well as the boolean value, but not all languages allow multiple return values.

@nick012000: I'm not sure why it was closed.  I didn't vote on it.  But I do think it would be a better challenge if it the program was required to take the dice rolls and spell levels as input.

Python 2.7, 285 bytes
from itertools import*
from random import*
def f(s,r):
 p=[];n=1;k=1;P=1;d=choices('123456',k=r);D=permutations(d,r);O=product('+-*/',repeat=r-1)
 while-~s*3>n:p+=P%k*[k];n,k,P=n+P%k,k+1,P*k*k
 return any(n in{eval('int(%s)'%'%s'.join(i)%o)for i in D for o in O}for n in p[-4:-1])

Technically conforms to the specifications of the challenge. Only returns True/False, does not expose the dice rolls used or the expression used to caller.
Also, this algorithm ignores grouping, since we can perform the same operations without grouping by using ordering instead. (This would not be true if exponentiation was one of the possible operations, for example.)
Exponential runtime, since it generates all possibilities and then checks if at least one solution exists.