[Question]
  [
**This is part of a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge. [Go here](https://codegolf.stackexchange.com/q/144601/8478) for the robbers' part.**
## The Cops' Challenge
You should write a program or function in a language of your choice, which outputs the string `Haystack`. However, it must be possible to remove some subset of characters from your program (without reordering the rest), such that the resulting string is *also* a valid program in the same language, which prints `Needle` instead. Both programs/functions may optionally print a single trailing newline (independently of each other), but nothing else. Output is case sensitive and must follow the exact casing provided.
Your goal, of course, is to hide the "needle" very well. But note that your submission can be cracked with *any* valid solution, not just the one you intended.
Please include in your answer:
* The language (and version if relevant) of your submission.
* The size of the Haystack program in bytes.
* The Haystack program itself.
* The output method if it's not STDOUT.
* If possible, a link to an online interpreter/compiler for your chosen language.
Your submission may be either a program or function, but not a snippet and you must not assume a REPL environment. You must not take any input, and you may output via STDOUT, function return value or function (out) parameter.
Both programs/functions have to complete within 5 seconds on a reasonable desktop machine and need to be deterministic. You must not use built-ins for hashing, encryption or random number generation (even if you seed the random number generator to a fixed value).
In the interest of fairness, there must be a freely available interpreter or compiler for your chosen language.
An answer is cracked if the Needle program is found. If your answer has not been cracked for 7 days, you may reveal the intended Needle program in your answer, which renders your submission safe. As long as you don't reveal your solution, it may still be cracked by robbers, even if the 7 days have already passed. The shortest *safe* Haystack program (measured in bytes) wins.
## Examples
Here are a couple of simple examples in different languages:
```
Ruby
Haystack: puts 1>0?"Haystack":"Needle"
Delete:        XXXXXXXXXXXXXXX
Needle:   puts "Needle"
Python 2
Haystack: print "kcatsyaHeldeeN"[-7::-1]
Delete:          XXXXXXXX        XX
Needle:   print "eldeeN"[::-1]
```
Note that the subset of removed characters doesn't have to be contiguous.
## Uncracked Submissions
```
<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 144600;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>
```
  
[Answer]
# [Haystack](https://github.com/kade-robertson/haystack), 84 bytes, [Cracked](https://codegolf.stackexchange.com/a/144613/68942)
```
0\\1-c\
//    
?10F17+c8F+4+cd8F+3+c6-c1+c,c2+c8+c|
 0   \1++c,c|
F/c++2F8
c\8F+2+cd
```
[Try it online!](https://tio.run/##FcoxCoBADETRPqewH2U3q6idXU6RZhkLwVIbwbuvcZqBzzvqc92VZ2vZXQe6pNTFZNNsuoCrYQL3uBGcByrYs0QHX@lyUFf87RVLBIqtQg8eZm/tAw "Haystack – Try It Online")
This looks (to me) rather convoluted but if you find the right subset it's a bit too easy... oh well, just to get us started :P
[Answer]
## [Hexagony](https://github.com/m-ender/hexagony), 37 bytes
```
H[@;(...e<l.a;./$.>;\sN;\ac.>).;;;._y
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/98j2sFaQ09PL9UmRy/RWk9fRc/OOqbYzzomMVnPTlPP2tpaLx6oDAA "Hexagony – Try It Online")
Just my obligatory Hexagony entry...
For convenience, here is the unfolded code:
```
   H [ @ ;
  ( . . . e
 < l . a ; . 
/ $ . > ; \ s
 N ; \ a c .
  > ) . ; ;
   ; . _ y
```
How this works:
The program starts off with `H`, then we move to IP #5. This IP starts in the west corner, bouncing and wrapping around while executing (in effect) `;a;y;s;` (so we've printed `Hays`). Then `s` gets incremented to a `t` by `)` and printed, then we pass through `Ne...(c` before getting to `a;c;` (still bouncing around a small section of the hexagon). The program hits the `_`, reflects up through `\` to `l` which gets decremented to a `k` by `(`, which passes through another `\` before being printed and the program terminates on the `@`.
Verbose version
```
H   H is entered into the current memory cell
[   We move to the previous instruction pointer (starting at the / and moving NE)
/   No-op
<   Mirrors the IP back to south-west
/   No-op (IP now wraps to the NE corner)
;   Outputs H
.   No-op
a   a is entered into the current memory cell
>   Mirrors the IP back to north-east
a   a is entered into the current memory cell
.   No-op
;   Outputs a (IP now wraps SE corner)
y   y is entered into the current memory cell
;   Outputs y
.   No-op
s   s is entered into the current memory cell (IP now wraps SW corner)
;   Outputs s
)   Increments the memory cell to t
\   Mirrors the IP west
;   Outputs t
N   N is entered into the current memory cell (IP now wraps to e)
e   e is entered into the current memory cell
... No-ops
(   Decrements the memory cell to d (IP now wraps to . on SE edge)
.   No-op
c   c is entered into the current memory cell
a   a is entered into the current memory cell
\   Mirrors the IP north-east
>   Redirects the IP east
;   Outputs a
\   Mirrors the IP south-west
c   c is entered into the current memory cell
;   Outputs c
_   Mirrors the IP north-west
.\. No-ops
l   l is entered into the current memory cell
(   Decrements the memory cell to k (IP now wraps to . on SE edge)
.\  No-ops
;   Outputs k
.   No-op
@   Terminates the program
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 146 bytes ([Cracked](https://codegolf.stackexchange.com/a/144626/69059))
```
([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
```
[Try it online!](https://tio.run/##VYwxDoAwDAO/Ew99BO@IMpQBCYEYWKu@PditEKJJ1To5e73rfpXtrEemuelABbQ@OzRxw3hb/0EEAI/g1YrSZRicGHtDZiuW6FdSwMjjRwwdruhAp8zMsjw "Brain-Flak – Try It Online")
## Intended solution, 80 bytes
```
([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
( ((   )(                  [(  (( (         )()()){})) []]   ({}(  )    ( (  ( ()(({}){}){}){}){}())))            ))    (((()[]){}){({}[()  ])}{})
```
[Answer]
# [Haskell](https://www.haskell.org/), 168 bytes ([Cracked by nimi](https://codegolf.stackexchange.com/a/145243/34531))
```
hays=map;hay=zipWith;stack=head;h=stack{-
 hay.(hays.(stackany hay$or id).stack hay
<*>hays(sum$stack haystack<$>hay))-}$words
 "Haystack Hayst ackH aysta ckH aystac k"
```
[Try it online!](https://tio.run/##PYqxCsMgFEX3fMUjOGgh/oCxc/YOnR8xoBgTUUNJS7/dqpRs5557NEa7rGvOGs8oHXpRQL6Nf5qkRUw4W6kXVELLNj5DB6XgtPacNofbWR3ZAxjFeHNVdOPtXjMaD0cu22Ak9WFs@JLXHlTsoJ/@FzSAQhM0BRfNYPvs0GwgwR/pkQLo/AM "Haskell – Try It Online") Evaluating the identifier `h` returns the string `"Haystack"`, after some deletions `h` yields `"Needle"`.
[Answer]
# JavaScript, 95 bytes (ES6), [Cracked](https://codegolf.stackexchange.com/a/144620/3845)
A function returning a string.
```
f=(k=b=x=35)=>x--?f(k*74837258394056219&268435455):k&2?'N'+(k^124038877).toString(b):'Haystack'
```
### "Haystack" demo
```
f=(k=b=x=35)=>x--?f(k*74837258394056219&268435455):k&2?'N'+(k^124038877).toString(b):'Haystack'
console.log(f())
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 41 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page) ([Cracked](https://codegolf.stackexchange.com/a/144667/53748))
```
“¿ọ⁽ṅ*FỊ⁼g£¡#!ʋzoɦṪ£ṢÞḲÐɠ`”m3⁾“»jVḟ“¡!pṄ»
```
**[Try it online!](https://tio.run/##AVwAo/9qZWxsef//4oCcwr/hu43igb3huYUqRuG7iuKBvGfCo8KhIyHKi3pvyabhuarCo@G5osOe4biyw5DJoGDigJ1tM@KBvuKAnMK7albhuJ/igJzCoSFw4bmEwrv//w "Jelly – Try It Online")**
Happy hunting!
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 32 bytes. [Cracked](https://codegolf.stackexchange.com/a/145736/60483)
I couldn't solve [Martin's](https://codegolf.stackexchange.com/a/144625/71256), so I'm posting my own.
```
];N.@cl;e@;;(\H/;ya;_.>s.;t//<._
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/z/W2k/PITnHOtXB2lojxkPfujLROl7PrljPukRf30Yv/v9/AA "Hexagony – Try It Online")
Here it is formatted:
```
   ] ; N .
  @ c l ; e
 @ ; ; ( \ H
/ ; y a ; _ .
 > s . ; t /
  / < . _ .
   . . . .
```
My aim with this was for both solutions to use as many IPs as possible, I got 6 for **Needle** and only 5 for **Haystack**.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 44 bytes ([Cracked](https://codegolf.stackexchange.com/a/144656/48934))
```
Kr."Dn2û"2sf!/+rrK2 2r."EL8"2Tr."AhÐP­®Z"2
```
[Try it here.](http://pyth.herokuapp.com/?code=Kr.%22Dn2%C3%BB%C2%82%222sf%21%2F%2BrrK2+2r.%22EL8%222Tr.%22Ah%05%C3%90P%C2%AD%C2%AEZ%222&debug=0)
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 226 217 bytes ([Cracked](https://codegolf.stackexchange.com/a/144809/75077))
First ever code golf, probably very easy but it was a fun challenge!
```
String d(){int h=3609000-5055+911,m=557558,s=15441301-157*10000;String d="0"+h*2+""+m*20+""+s*7,x="",y;for(int g=0;g<d.length();g+=3){y="";for(int e=0;e<3;e++)y+=d.charAt(e+g);x+=(char)Integer.parseInt(y);}return x;}
```
[Try it online!](https://tio.run/##PY/BToQwFEXX@hUNq5YCaYepOOl04dKFq1kaFxVqYYRC2jJCCN@ORaOrm3Nz7kveVd5k2g/KXKvPrWylc@BFNmYZxve2KYHz0oe49U0FutDDi7eN0a9vQKLlMjuvuqwffTaE1kOjvn7WEGUVRIivd9uvDwIuwQC1yB/IiRCSMsIYPlGadIKxgrHHxAnKjkeaE5pSVsQ0WIT/7UVEIlzHBxxFuIsPZE8XF8kkoiiZ@Udv4X5fC8L1ucpaZbSvIeIaixwtc7D@HRUcdc65whjNWFRZWUv75KHCGvEJC7gzejZeaWWzQVqnAsA5/GOVH60BE1/vt3X7Bg "Java (OpenJDK 8) – Try It Online")
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 148 bytes ([Cracked](https://codegolf.stackexchange.com/a/145026/74216))
```
6 93 3 9 2 2**+*+483622 1 2 3 3*+3*+89 47*+*+3 5 2* 269 158 9**107 97*2 4*++2 3 3*+42 14 2**+*+5*+5 2148 1 6 2*+*+68262 5 280 7 2 3 3*+5 2**+*+*+*+P
```
[Try it online!](https://tio.run/##NY27EcAwCENXUQ1NjDGGLbJDsv8KjnznHKqePrzPWoHq6CgYTERFPXuYoRHQEKWy4HN7HYMpWBTaSJRIuyZqisFF9TScbT9rg4I1Tw4GGVGkhe2hvDD/L@Pk991rfQ "dc – Try It Online")
It is rather simple, but I hope it will be at least a little fun to solve :з
[Answer]
# JavaScript, 119 bytes (ES6), [Cracked](https://codegolf.stackexchange.com/a/144652/36445)
A function returning a string. Quite long and not so hard, but hopefully fun.
```
_=>(+{}+['H'])[+[3]]+(+[][[]]+[])[+!!3]+(+[][[]]+['y'])[3]+(+[][[]]+['s'])[-~2]+(~![]+['t'])[2]+(+[][[]]+[])[+!!3]+'ck'
```
### "Haystack" demo
```
let f =
_=>(+{}+['H'])[+[3]]+(+[][[]]+[])[+!!3]+(+[][[]]+['y'])[3]+(+[][[]]+['s'])[-~2]+(~![]+['t'])[2]+(+[][[]]+[])[+!!3]+'ck'
console.log(f())
```
[Answer]
## Python 2.7.2, 103 / 117 bytes, [Cracked](https://codegolf.stackexchange.com/a/144701/71546)
**Function Version (117 bytes):**
```
def e():
 a,b,s=20070763850923833476353301471991752,0b1010100010010011,""
 while a>0:
  s=chr(a%b)+s
  a//=b
 print s
```
**Program Version (103 bytes):**
```
a,b,s=20070763850923833476353301471991752,0b1010100010010011,""
while a>0:
 s=chr(a%b)+s
 a//=b
print s
```
This should print `Haystack` well. Tested on [Python Fiddle](http://pythonfiddle.com/).
Btw this is the first attempt.
Not sure if the program version is counted as a snippet, so I put both versions here.
[Answer]
## Python 2.7.10 with Numpy 1.12.1, ~~208~~ 209 bytes ([cracked](https://codegolf.stackexchange.com/a/144734/46523))
It appears that there is a Needle *and* a Haystack in Numpy! Here is the Haystack; see if you can find the Needle. I hope you have as much fun searching for the Needle as I had hiding it.
```
import numpy
print "".join([dir(numpy)[int(i)][1-0] for i in numpy.poly1d([-1*1433/252e1,-3232/1920.,4026./72/2/3.,613/(6*4.)*1,-4723./1.8e2,-9763/120.,-2689/(-1+5*17.),1+138*.4*2])(numpy.arange(-12/3,13%9))])
```
It outputs as specified:
```
Haystack
```
You can [repl.it](https://repl.it/MRuh/0).
[Answer]
# Java 8, 321 bytes, [Cracked](https://codegolf.stackexchange.com/a/144792/52210)
```
v->{String h="Haystack";int x=-7;return x<0?h:new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~-~-~1^-x++*x)+151),new Byte("2"+"1+\"0+\"".length()+(x=h.length()*4/x)+"-x-7")}).toByteArray())+(new StringBuffer("hidden".substring(++x%3^4,--x-x--).replaceFirst("dd","e"+(char)(x*211%+93))).reverse());}
```
[Try it here.](https://tio.run/##ZVHRSsMwFH33K0JASJYlrttkaK3iHkQf3Ivgy9wga7O2W5eWNK0Zo/56vXVFHyS5JDfn3JvDuTtZS54XSu@ifRtmsizRq0z16QKhVFtltjJUaNGlCL1Zk@oYheQ9TyNUUx9eGwjYpZU2DdECaRSgtub3p56cBPhZHgEO99iHjsgFfOYbZSujkbsbPSS3Wn32rUl33YEicZA2EfM0fgENsTI/wOZo1XJ1It1JCfni/5a35o6xgaPMu/bosCuaA5ngMWbYYx94BIFFpnRsE0IZcUHymw2mV1CIueMzTBsqbN7VPhojj4QC90/mvNpuQRNO0ihSGouy2pRn/Yy5y8l6OuTQxXFOhVFFBg4@paa0BEd4iBVmJEykocQNxp53yW4mlHbEWplSwU9@0/pnU4tqk4Gpvbd1Z/oBZkPOKpYrJGk/GDBYHUReWVEAZIkWIdFVltF@Rk37DQ)
More readable:
```
v->{
  String h="Haystack";
  int x=-7;
  return x<0?
          h
         :
          new String(new java.math.BigInteger(new byte[]{
            (byte)((~-~-~-~-~-~-~-~-~-~1^-x++*x)+151),
            new Byte("2"+"1+\"0+\"".length()+(x=h.length()*4/x)+"-x-7")
          }).toByteArray())
          +(new StringBuffer("hidden".substring(++x%3^4,--x-x--)
             .replaceFirst("dd","e"+(char)(x*211%+93))
            ).reverse());
}
```
Not sure if it's too long/hard.. Then again, Java in general is pretty long to begin with, so hiding the 'Needle' properly of course increases the byte-count quite a bit..  
If no one cracks it, I'll add some spoiler-tips later on.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 185 bytes, [cracked by cab404](https://codegolf.stackexchange.com/a/144955/6828)
```
x='yGwztsPXhxDkBKlCYdFjQnpUROfoHvqmTgbaJSLcEiZrIAuMVNW'
s="n=x.to_i 36;x.bytjs.jach_cons(3){|a,b,c|n+=n*b%c;n*=a^b};puts n%8675309==1388649 ?'Njjdlj':'Haystack'"
eval s.tr ?j,s.size.chr
```
[Try it online!](https://tio.run/##BcHbboIwGADge5@iMTGdShoNiihpzHQHz7p52ryYaesBKhblLwrqnh2/L4x4kqYxxcnn9aZh8uPGb4dW32//bj7klzrNv8e7oHM5H2d7znrTgXj3VmH3NRouRkucAZpVNCY6WHvItJyY8ERLIJIJdy0CBS9m/v5gBjfEQxWpKvCccFSBsj/@75wiDUjlbKtWNUt1SsumbVuVOmrikZQbX@IG7rAENBMHnM1sL8xHQHSImtIAAt5tS4QbpukT "Ruby – Try It Online")
I'll try to come up with something sneaky, but for now here's a try at "simple but obnoxious."
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 188 bytes ([Cracked](https://codegolf.stackexchange.com/a/145332/71256))
I only just saw Funky Computer Man's [answer](https://codegolf.stackexchange.com/a/144608/71256) As I posted this.
It is somewhat obfuscated.
```
((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
```
[Try it online!](https://tio.run/##VU5JCsAwCPzOeOgPQj4iHtJCobT00GvI2@1koUsUNaMzOl9pO6f1SLs73ifVJBf6LzNIQC46RhpoAqiaEZcQq8dHgm2iCjESOcSiNYcmGNQU5OQSIpVaBdQfOk@/B4UKcUeXiOMyE3eflhs "Brain-Flak – Try It Online")
### Intended solution, 96 bytes:
```
((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])((((((((()()()){}){}){}()){}){}()<>)<>)(()()()){}())<>(((({}[()]<>)()))[(((()()()){}())()){}{}])
(((((((( (()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwMGNEFQs7oWgmBMDU0bOxBCyAMJGzuQhuraaA3NWJCcpqZmNLIRQAJMV9fGav7//183GQA)
[Answer]
# T-SQL, 757 characters [CRACKED](https://codegolf.stackexchange.com/questions/144601/find-the-needle-in-the-haystack-robbers/145348#145348)
Apologies for deleting my previous answer--I edited it too many times as I obfuscated, and didn't want to give anything away. :)
In any case, obfuscating in SQL is a bit difficult, unless you want to do crazy stuff like [this](https://blogs.oracle.com/sql/obfuscated-sql-contest-winners), and I wasn't that invested.
Also, I unabashedly do not apologize for naming my variables after Dota.
[SQL Fiddle](http://sqlfiddle.com/#!6/cfcd39/6/0)
```
create table a(l int,c int)
insert into a values (1,10),(2,1),(3,8),(4,0)
go
;CREATE FUNCTION b(@ varchar(max)) returns varchar(max) as
begin return 'char('+@+'),'''','end 
go
;CREATE FUNCTION h(@ varchar(max),@a varchar(max), @b varchar(max), @c varchar(max), @d varchar(max), @e varchar(max), @f varchar(max), @g varchar(max), @h varchar(max))
returns varchar(max) as 
begin
return replace(replace(replace(replace(@,@a,@b),@c,@d),@e,@f),@g,@h)
end
declare @x varchar(max),@ int=1,@y varchar(99)=''
,@D varchar(4)='Ha',@O varchar(4)='ys'
,@T varchar(3)='ta',@A varchar(4)='ck'
WHILE @<=4
BEGIN
set @y+=(SELECT dbo.b(c+100)from a where l=@)+' '
set @+=1
END
SELECT @x='select
left(dbo.h('''+@D+@O+@T+@A+''','+ left(@y,len(@y)-1) +'),char(56))'
execute(@x)
```
If this is the easiest answer in this thread, you're probably right. :P It's hard to trick SQL.
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 40 bytes, [cracked](https://codegolf.stackexchange.com/a/145344/70424)
```
(78)"e"&p"Ha"s"yst"l"ck"&o(100)"l"l'&'o;
```
[Try it online!](https://tio.run/##y6n8/1/D3EJTKVVJrUDJI1GpWKmyuEQpRyk5W0ktX8PQwEATyMlRV1PPt/7/HwA "Ly – Try It Online")
Oh boy, another Ly CNR submission. These haven't worked very well historically (possibly due to me and not the language), ~~but we'll see how this fares~~ and today is no exception.
Solution:
> 
>  `(78)"e"sl(100)"l"l&o;`, remove `XXXXXX XXXXX XXXXXX X X` with seven leading spaces
> 
> 
> 
[Answer]
# [Java](http://openjdk.java.net/), 345 bytes, [Cracked](https://codegolf.stackexchange.com/a/145848/55735)
```
import java.util.*;interface Main{static void main(String[]args){Stack<Hay>s=new Stack();s.add(new Needle());for(int i=0;i<1000;i++)s.add(new Hay());System.out.println(s.get(s.indexOf(new Hay())+1).a);}}class Needle extends Hay{{a="Needle";}}class Hay{String a="Haystack";public boolean equals(Object o){return getClass().equals(o.getClass());}}
```
[Try it online!](https://tio.run/##TY@xbsMgEIZfBXmCWkXOTNylS5Y2g8eqw9mcIxwMLpzTRFae3YUmarqA7rtPd/8NcIJnP6Eb9HFdzTj5QGxIUM5krHxSxhGGHjpkb2DcEgnIdOzkjWZjAryhYNzh4xPCIYqlIeiO2x1cXmLt8Jv91lyoKEFrnsk7orbIhVC9DzxNZ6aulNluqip9ZSkeahqTveYSCUfpZ5JT2kXW8SgPSOk1TuN53/@zy42QINT12lmI8b6N4ZnQ6ZidZYG6uOHiT8v8dghL3VTFnLtQ09zadG3rvUVwDL9msJHv2wE7Yl4sAWkOjqUwr3kOF/KuePlgOc26/gA "Java (OpenJDK 8) – Try It Online")
Really long and probably easy to crack, but at least it's got a `Stack<Hay>`!
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `o`, 51 bytes
```
‛Ha:₍₴Cv∑∑Ṙ⌊√‹½⇩⇩²C:₴«•∞yλ;ß4ġ∆Ė_□∴9«øc:3Ẏ$4ȯ∇ppĖ5e
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=o&code=%E2%80%9BHa%3A%E2%82%8D%E2%82%B4Cv%E2%88%91%E2%88%91%E1%B9%98%E2%8C%8A%E2%88%9A%E2%80%B9%C2%BD%E2%87%A9%E2%87%A9%C2%B2C%3A%E2%82%B4%C2%AB%E2%80%A2%E2%88%9Ey%CE%BB%3B%C3%9F4%C4%A1%E2%88%86%C4%96_%E2%96%A1%E2%88%B49%C2%AB%C3%B8c%3A3%E1%BA%8E%244%C8%AF%E2%88%87pp%C4%965e&inputs=5%0A3&header=&footer=)
Have fun!
So, here's an explanation of the code:
```
‛Ha                                      # Push 'ha'
   :₍                                    # Duplicate and parallel apply...
     ₴                                   # Flatprint
      C                                  # And charcode, wrapped into a list
       v∑∑Ṙ                              # Get sum, concatenate, reverse (`961aH`)
           ⌊√‹½                          # Intify, square root, decrement and halve (15)
               ⇩⇩²C                      # Subtract 4, convert to char, which happens to be y
                   :₴                    # Dupe and flatprint.
                     «...«               # Push a string, specially chosen, see below
                          øc             # Compress
                            :3Ẏ$4ȯ∇pp    # Insert ToS (`y`) at char 3
                                     Ė   # Evaluate
                                      5e # Every fifth character
```
So, I realised I could use the compressed string `‛₍∞` as the needle program. I could easily sneak in a `‛` and `₍`, but `∞` was proving to be a problem. Eventually, I managed to construct a compressed string that contained `∞` and `y`, and had the property that if you took every fifth character, you got 'stack'.
So yeah, this was tricky.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 44 bytes
```
17SǏ⌊0»¹∇ḃF2»*»∷J∇Y.ḊṖ¼ḭ¦]uy»S4ẇṫ½Y⌊$oḢJCṅĖǐ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=17S%C7%8F%E2%8C%8A0%C2%BB%C2%B9%E2%88%87%E1%B8%83F2%C2%BB*%C2%BB%E2%88%B7J%E2%88%87Y.%E1%B8%8A%E1%B9%96%C2%BC%E1%B8%AD%C2%A6%5Duy%C2%BBS4%E1%BA%87%E1%B9%AB%C2%BDY%E2%8C%8A%24o%E1%B8%A2JC%E1%B9%85%C4%96%C7%90&inputs=&header=&footer=)
[Answer]
# TI-BASIC, 119 bytes (Safe)
Output stored in `Ans`.
```
"TIBASIC→Str1
length(Ans→X
Str1
For(I,X,2(7-4not(X-1
Ans+sub("ACDEHKLNSTY",inString("ABCDEFGHIJK",sub("KCBADAEDJDHIGF",1+remainder(11I-1,14),1)),1
End
sub(Ans,1+X,length(Ans)-X
```
## Solution
Remove characters from `Str1` to give it a length of 1.
```
"C→Str1
length(Ans→X
Str1
For(I,X,2(7-4not(X-1
Ans+sub("ACDEHKLNSTY",inString("ABCDEFGHIJK",sub("KCBADAEDJDHIGF",1+remainder(11I-1,14),1)),1
End
sub(Ans,1+X,length(Ans)-X
```
[Answer]
# PHP, 44 bytes, [Cracked](https://codegolf.stackexchange.com/a/145849/72733)
fairly easy to crack; but I like it.
```
for($i=~1;$c=H_aNyesetdalcek[$i+=2];)echo$c;
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/2d59e50d8293febd1368cc57731f0e4dd83ae956).
[Answer]
# [Aceto](https://github.com/aceto/aceto), 154 bytes (Safe)
```
              27\'dNU   QJi9MLJ€{{x(}]J{'!o∑€xiDQxsJ(]sicpicp1.2sJJicp90I.2+D/edxi-'>xd80J0IJicx'NIx5sJsJidcpIcpL7sssJicpei7+ UUdJicpLI7sJicpx'p\p9*coJcU'p+\p   
```
[Try it online!](https://tio.run/##S0xOLcn//18BDozMY9RT/EKBrECvTEtfH69HTWuqqys0amO9qtUV8x91TAQKVGS6BFYUe2nEFmcmFwCRoZ5RsZcXkGFp4KlnpO2in5pSkamrbleRYmHgZeAJlKlQ9/OsMC32KvbKTEku8Ewu8DEvLi4GaUnNNNdWCA1NAbF9PM3BYhXqBTEFllrJ@V7JoeoF2jEF//8DAA "Aceto – Try It Online")
> 
>  'N'ed'd80J0IJic'eUpppppp [Try it online!](https://tio.run/##S0xOLcn//19BQd1PPTVFPcXCwMvA0yszWT01tAAM/v8HAA "Aceto – Try It Online")
> 
> 
> 
```
Explanation:
<space>*2 - Two spaces for the hilbert curve to work right
'N pushes 'N' onto the stack
'e pushes 'e'
d duplicates it
'd pushes d
80 pushes 8, 0
J concats top two values
0I pushes 0, pops, increments, pushes back on, net effect: pushes 1
J concats to '108'
i converts to integer
c pops and pushes ascii equiv on stack
'e pushes 'e' (again)
U reverses the stack
and the p's print out the stack
```
[Answer]
# [Rattle](https://github.com/DRH001/Rattle), 55 bytes
```
Haystack&Needl|Ip0=2+(1*2)!Ps[bg0*3b^](`+5);$b|1,%(?3b)
```
[Try it Online!](https://www.drh001.com/rattle/?flags=&code=Haystack%26Needl%7CIp0%3D2%2B%281*2%29!Ps%5Bbg0*3b%5E%5D%28%60%2B5%29%3B%24b%7C1%2C%25%28%3F3b%29&inputs=)
This isn't terribly difficult but it's not trivial either (note that "Needle" is missing the last "e" near the beginning of the code).
Hint: the Needle program will not have a trailing newline, while the Haystack program does.
]