[Question]
  [
Based on the [Duct tape can fix anything](https://codegolf.stackexchange.com/questions/26778/duct-tape-can-fix-anything) question, that was too broad, with very similar rules. Only this time the objective is very specific:
# The challenge
Your mission is to make a program that displays `hello mom` -- without ever writing a single line of code.
You can only use code which is already written for you, both in questions and answers from StackOverflow. All you can do is duct tape it all together the best you can. And of course, it's very important that we provide appropriate attribution so that we don't get our rights terminated.
---
# Rules
1. You must include links to the questions/answers you used in your answer.
2. You *may not* modify the code you find, with the following exceptions:
a. You may rename variables, functions, and methods. (This doesn't mean you can change a method *invocation*, by changing, say `scanner.nextInt()` to `scanner.nextLine()` and claiming that you're changing a method name. The change must be in the definition or reference to the same entity.). *The solution should still work if variables, functions or methods would be renamed again, so renaming code to contain `hello mom` as a variable name does not count.*
b. You may adjust indentation appropriately.
c. You can assume that the proper modules are loaded for the code snippets to work. (e.g., `import` statements for Java and Python, `using` statements for C# and C++, and their equivalents in all languages) If the code snippet includes the `import`s for you, you can move them to the top of the code.
d. If the language requires the code to be in some kind of method body to execute (e.g., `public static void main(String[] args)` for Java, `static int Main(string[] args)` for C#, and so on), you can wrap your code in the appropriate method. But the *contents* of that main method must remain unmodified.
3. You must supply an explicit list of any variable/method/function/class rename-ings performed.
4. You can't take snippets of snippets (meaning if you take a code block from a post, you take the whole thing)
5. Provide a brief description of what the code does for people who aren't intimate with the language you're using.
6. You must use snippets posted before this challenge was started.
7. Popularity contest, so the most upvotes wins!
# Deadline
I will accept the the submission that has the most votes around the end of mothersday (midnight of the UTC-11 timezone), but later submissions can still get votes.
  
[Answer]
# Brainfuck
Oh god why did I do this to myself?
It is actually possible to find each BF symbol by itself as a code snippet in some answer somewhere. The interesting bit was piecing together bits of other people's code, each representing a block of BF instructions. Unfortunately there are basically no unmatched `[` and `]` symbols out there, so I had to cheat a bit for those, and I had to get an awful lot of mileage out of a funky Haskell snippet which had a bunch of pluses in it. There are probably others out there. Beyond that, here's some Frankensteined code:
```
byte x = 1;
byte y = 2;
byte z = x + y;   // ERROR: Cannot implicitly convert type 'int' to 'byte'
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
[
int a = (b > 10) ? some_value                 
                 : another_value;
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
int a = (b > 10) ? c : d;
byte x = 1;
byte y = 2;
byte z = x + y;   // ERROR: Cannot implicitly convert type 'int' to 'byte'
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
?"<<-"
]
exec >{space}> (command)
byte z = (int) x + (int) y;
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
find . -type f -print -exec cat {} \;
git reset .
byte x = 1;
byte y = 2;
byte z = x + y;   // ERROR: Cannot implicitly convert type 'int' to 'byte'
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
System.out.print("B");
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
fatal: Failed to resolve 'HEAD' as a valid ref.
while read p; do 
echo $p
done < $filename
static HMODULE hMod = NULL;
  static bool once = false;
  if (!once++)
    hMod = LoadLibrary("xxx");
 if (originalValue.length > size) {
static HMODULE hMod = NULL;
  static bool once = true;
  if (once--)
    hMod = LoadLibrary("xxx");
$ cd /usr/local/wherever
$ grep timmy accounts.txt
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub}
ls -ld $(find .)
git commit --amend -m "New commit message"
wget -q -O - $line 
git rebase --interactive $parent_of_flawed_commit
find . -type f -user 'user1' -maxdepth 1
```
And, since my mother is British, the output is quite simply `hello mum`
# Bibliography:
<https://stackoverflow.com/questions/17845014/what-does-the-regex-mean>
`[` and `]`, with apologies
<https://stackoverflow.com/a/21460161/2581168>
```
find . -type f -print -exec cat {} \;
```
<https://stackoverflow.com/questions/6161328/what-exactly-does-this-do-exec-command>
```
exec >{space}> (command)
```
<https://stackoverflow.com/questions/20130538/what-is-in-haskell>
```
addop = do {symb "+"; return Op Add}  +++ do {symb "-"; return Op Sub} 
```
<https://stackoverflow.com/questions/21947452/why-is-printing-b-dramatically-slower-than-printing>
```
System.out.print("B");
```
<https://stackoverflow.com/questions/941584/byte-byte-int-why>
```
byte x = 1;
byte y = 2;
byte z = x + y;   // ERROR: Cannot implicitly convert type 'int' to 'byte'
```
<https://stackoverflow.com/a/160295/2581168>
```
int a = (b > 10) ? c : d;
```
And
```
int a = (b > 10) ? some_value                 
                 : another_value;
```
<https://stackoverflow.com/questions/13273002/what-does-mean-in-r>
```
?"<<-"
```
<https://stackoverflow.com/questions/3450420/bool-operator-and>
```
static HMODULE hMod = NULL;
static bool once = false;
if (!once++)
    hMod = LoadLibrary("xxx");
```
And
```
static HMODULE hMod = NULL;
static bool once = false;
if (!once--)
    hMod = LoadLibrary("xxx");
```
<https://stackoverflow.com/questions/22776085/in-which-case-will-size-originalvalue-length-in-string-constructor-string>
```
if (originalValue.length > size) {
```
<https://stackoverflow.com/questions/3797795/does-mean-stdout-in-bash>
```
wget -q -O - $line 
```
<https://stackoverflow.com/questions/179123/how-do-i-edit-an-incorrect-commit-message-in-git/179147#179147>
```
git commit --amend -m "New commit message"
```
And
```
git rebase --interactive $parent_of_flawed_commit
```
<https://stackoverflow.com/questions/14763413/grep-ls-output-across-tabs/14763499#14763499>
```
find . -type f -user 'user1' -maxdepth 1
```
<https://stackoverflow.com/questions/945288/saving-current-directory-to-bash-history>
```
$ cd /usr/local/wherever
$ grep timmy accounts.txt
```
<https://stackoverflow.com/questions/348170/undo-git-add-before-commit/682343#682343>
```
fatal: Failed to resolve 'HEAD' as a valid ref.
```
[Answer]
# Java
Start with these:
<https://stackoverflow.com/a/19509316/1768232>
```
String myStr = "hello";
String myStr1 = "hello";
```
<https://stackoverflow.com/a/8341513/1768232>
```
String[] history = new String[] { "hey", "you", "Mom" };
```
<https://stackoverflow.com/a/23300004/1768232>
```
String editednames = titleCase(name);
```
<https://stackoverflow.com/a/20698093/1768232>
```
myString = myString.toLowerCase();
```
<https://stackoverflow.com/a/19393222/1768232>
```
System.out.println(Name + " " + Income);
```
<https://stackoverflow.com/a/1181979/1768232>
```
public static <T> T last(T[] array) {
   return array[array.length - 1];
}
```
Add the required `class` and `public static void main(String[] args){ }` as allowed in Rule #2d (not around the static method), and change some variable / method names in exactly 3 of 6 snippets:
* Change `name` -> `history` in the third snippet
* Change `editednames` -> `myString` in the third snippet
* Change `Name` -> `myStr` in the fifth snippet
* Change `Income` -> `myString` in the fifth snippet
* Change `last` -> `titleCase` in the sixth snippet
Resulting program:
```
public class DuctTape {
  public static void main(String[] args) {
    // https://stackoverflow.com/a/19509316/1768232
    String myStr = "hello";
    String myStr1 = "hello";
    // https://stackoverflow.com/a/8341513/1768232
    String[] history = new String[] { "hey", "you", "Mom" };
    // https://stackoverflow.com/a/23300004/1768232
    String myString = titleCase(history);
    // https://stackoverflow.com/a/20698093/1768232
    myString = myString.toLowerCase();
    // https://stackoverflow.com/a/19393222/1768232
    System.out.println(myStr + " " + myString);
  }
  // https://stackoverflow.com/a/1181979/1768232
  public static <T> T titleCase(T[] array) {
    return array[array.length - 1];
  }
}
```
Output:
```
hello mom
```
[Answer]
# C#
Possibly crazy, roundabout, and convoluted way to get to the (exact) result - with only variable renames and without any literal "mom" in any of the code.
Reading the "if you take a code block from a post, you take the whole thing" rule very literally probably didn't help - but made it more fun.
```
using System;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
public class Program
{
    void Main()
    {
        // Step 1
        var n = 3;
        var helloAndGoodbye = "12345678900"
                    .Select((c, i) => new { letter = c, group = i / n })
                    .GroupBy(l => l.group, l => l.letter)
                    .Select(g => string.Join("", g))
                    .ToList();
        // Step 2
        string place = "world";
        string greet = String.Format("Hello {0}!", place); 
        // Step 3
        byte[] b1 = System.Text.Encoding.UTF8.GetBytes (greet);
        byte[] b2 = System.Text.Encoding.ASCII.GetBytes (greet);
        // Step 4
        string encryptionKey = "test";
        var md5 = MD5.Create();
        var keyBytes = Encoding.UTF8.GetBytes(encryptionKey);
        byte[] encryptionKeyBytes = md5.ComputeHash(keyBytes);
        // Step 5
        string strName = md5.GetType().Name;
        if(strName == "Person")
        {
            //My Code
        }
        // Step 6
        string HashAlgorithm = new string(strName.Take(n).ToArray());
        // Step 7
        int previousYear = DateTime.Now.AddYears(-1).Year;
        // Step 8
        string myString = previousYear.ToString();
        // Step 9
        string totallyRandomString = new string(myString.Take(n).ToArray());
        // Step 10
        int myInt = System.Convert.ToInt32(totallyRandomString);
        // Step 11
        int x = myInt << 1 + 1;
        // Step 12
        PasswordDeriveBytes DerivedPassword = 
                    new PasswordDeriveBytes(place, b1, HashAlgorithm, x);
        byte[] KeyBytes = DerivedPassword.GetBytes(32);
        // Step 13
        string base64 = Convert.ToBase64String(KeyBytes);
        byte[] bytes = Convert.FromBase64String(base64);
        // Step 14
        var split = base64.Split('/');
        var last = split[split.Length -1];
        var prev = split[split.Length -2];
        // Step 15
        string truncatedToNLength = new string(last.Take(n).ToArray());
        // Step 16
        Regex rgx = new Regex("[^a-zA-Z0-9 -]");
        greet = rgx.Replace(greet, "");
        // Step 17
        var newString = greet.Replace(place.ToString(), truncatedToNLength);
        // Step 18
        var searchStr = newString.ToLower();
            searchStr = searchStr.Trim();
        // Step 19
        Console.WriteLine(searchStr); 
    }
}
```
### .NET Fiddle
<http://dotnetfiddle.net/PbjhPn>
<http://dotnetfiddle.net/bg20wb> (with redundant lines in code blocks removed)
### Short explanation
Basically, we get "Hello world!" from a simple string format. Now we need "mom" to replace it. For that, we use the Base64 encoded result of running 804 iterations of PBKDF1 using MD5 with "world" as password and "Hello world!" as salt. That yields a string "ciSf5cCls1l/**MoM**...". We extract that "MoM" and use it as a replacement for "world". Then we clean up the string.
How do we get to 804? The previous year clipped to three characters (= "201"), and then multiplied by 4.
### Long explanation and attributions
**1:** We start with a bit of rule-following overkill.
The integer 3 is a very very important constant in this program.
Here we assign that integer to `n`. We must include the entire block from the source. It may be redundant, but it will compile just fine, as long as we rename the `split` variable that we'll be needing later. [Source](https://stackoverflow.com/a/4133512/1169696)
Replaced variable names:
```
split              > helloAndGoodbye
```
**2:** Set up starting string ("Hello world!"). [Source](https://stackoverflow.com/a/7077/1169696)
This is a very personal message to our mom. So we obviously need some cryptography to deal with those NSA types. For that, we'll need some parameters, which we prepare now.
**3:** Convert `greet` ("Hello world!") to byte array for salting. [Source](https://stackoverflow.com/a/472918/1169696)
```
myString           > greet
```
**4:** Although we're using cryptography, we don't actually need to instantiate the MD5 class. We do, however, need the string "MD5" assigned for one of our parameters to be used further down - and that's not easy to find in usable code. So we'll take another... "shortcut"... Once again, entire code block included as per rules, although we only need the second line. [Source](https://stackoverflow.com/questions/11038954)
**5:** Now we need the name of the type of the `md5` variable (`MD5CryptoServiceProvider`). The `if` is yet another redundancy. [Source](https://stackoverflow.com/questions/8207447)
```
entity             > md5
```
**6:** Get the first 3 (ooh, there's our constant!) characters of the type name. [Source](https://stackoverflow.com/a/3566852/1169696)
```
s                  > strName
truncatedToNLength > HashAlgorithm
```
**7:** Code-trolling: Using `DateTime.Now` would mean this would only work until 2019. To make it a bit more future proof, we use the previous year. Then it will work until 2020 ;-)[Source](https://stackoverflow.com/a/13122370/1169696)
**8:** Convert our `previousYear` to string. [Source](https://stackoverflow.com/a/3081919/1169696)
```
myInt              > previousYear
```
**9:** Hey, code reuse! ;-) Get the first 3 (our constant!) characters of our year. [Source](https://stackoverflow.com/a/3566852/1169696)
```
s                  > myString
truncatedToNLength > totallyRandomString
```
**10:** Aaaaaaaand... convert the result back to integer. [Source](https://stackoverflow.com/a/2344421/1169696)
```
myString           > totallyRandomString
```
**11:** Eric Lippert makes every answer better. Multiply by 4 in a roundabout way. [Source](https://stackoverflow.com/a/3060658/1169696)
```
y                  > myInt
```
**12:** Send `place` (password) and `greet` (salt) through PBKDF1 using MD5 with `x` (which is now `201*4 = 804`) iterations. [Source](https://stackoverflow.com/questions/9231754)
```
Password           > place
SaltValueBytes     > b1
PasswordIterations > x
```
**13:** Jon Skeet also makes every answer better. Convert our derived password to base 64. We throw out the `bytes` array. [Source](https://stackoverflow.com/a/1134696/1169696)
```
bytes (first occurrence) > KeyBytes
```
**14:** What a crazy random happenstance! We now have a `base64` with "MoM" in it. Conveniently, right before "MoM" is a single '/'. So split the string with that character as delimiter: [Source](https://stackoverflow.com/a/10387374/1169696)
```
filePath          > base64
```
**15:** Hey, our favorite piece of code reuse tape! Get the first 3 (constant!) letters of `last`. [Source](https://stackoverflow.com/a/3566852/1169696)
```
s                 > last
```
**16:** Remove "!". [Source](https://stackoverflow.com/a/3210410/1169696)
```
str               > greet
```
**17:** MoM is our world - so make the string reflect that (replace "world" with "MoM"). [Source](https://stackoverflow.com/a/1948984/1169696)
```
someTestString   > greet
someID           > place
sessionID        > truncatedToNLength
```
**18:** Finally, convert to lower case. Trim for good measure (or possibly because it's part of the duct tape block). [Source](https://stackoverflow.com/questions/5303231)
```
wordToSearchReplacemntsFor > newString
```
**19:** Output to console. [Source](https://stackoverflow.com/questions/8695946)
```
_surface         > searchStr
```
### A bit of "bonus material"/commentary
* At first I tried every combination of built-in cryptographic hashes (each combined with HMAC) and inputs ("world", "Hello world!", "Hello world", "hello world" etc.) to see if something would miraculously give a usable output to derive "mom" from - before taking the easy route of just looking for a number of iterations of PDKDB1 (or 2) that would be useful.
* Wasn't quite happy with the use of the year as input for the 201\*4 = 804 iterations. At first I tried to find some useful code for `HttpStatusCode.Created` (201) to use as input - with a "troll excuse" along the lines of "we've created our 'Hello world!' string, so a good practice would be to use a 'Created' status code" here. Unfortunately, I never found a usage of the `HttpStatusCode` enumeration that didn't introduce a dependency on most of the ASP.NET WebAPI framework.
* The start of the code (the "Hello world!" string format) was never looked at again after I first added it. If I had, yeah, I might have realized that the assignment of `place` was actually in a different block in the source - so I could have simply assigned my derived "mom" to `place` rather than using "world" and later replacing it. Ah well.
[Answer]
# Befunge 98
* [`var abc = function(){};`](https://stackoverflow.com/a/338053/1896169)
* [`display: table-*`](https://stackoverflow.com/a/1030017/1896169)
* [`+`](https://stackoverflow.com/a/7124907/1896169)
* [`, new {area = ""}`](https://stackoverflow.com/q/2270861/1896169)
* [`byte z = x + y;`](https://stackoverflow.com/a/941665/1896169)
* [`"1,23,4"`](https://stackoverflow.com/q/7124884/1896169)
* [`String[] temp = data.split("\\s+\\^,?\"'\\|+");`](https://stackoverflow.com/q/23561872/1896169)
* [`List<Set<Integer>> foo;`](https://stackoverflow.com/q/23448156/1896169)
* [`: base(name)`](https://stackoverflow.com/q/10605798/1896169)
* [`10001.10010110011`](https://stackoverflow.com/a/618596/1896169)
* [`[5326, 4223, 1204]`](https://stackoverflow.com/q/23557240/1896169)
* <https://stackoverflow.com/q/23044400/1896169>
```
Runnable prs = new Runnable() {
    public void run() {
        Document doc = null;
        try {
            doc = Jsoup.connect("http://play.radio.com/").get();
        } catch (IOException e) {
            e.printStackTrace();
        }
        parser.postDelayed(prs, 10000);
    }
};
```
* [`$selector.append("somestuff");`](https://stackoverflow.com/q/1180213/1896169)
* [`-new Date().getTimezoneOffset()/60;`](https://stackoverflow.com/a/1809974/1896169)
* <https://stackoverflow.com/a/8928476/1896169>
```
 [0000] push        ebp
 [0001] mov         ebp,esp
 [0003] push        edi
 [0004] push        esi
 [0005] push        ebx
 [0006] sub         esp,1Ch
 [0009] xor         eax,eax
 [000b] mov         dword ptr [ebp-20h],eax
 [000e] mov         dword ptr [ebp-1Ch],eax
 [0011] mov         dword ptr [ebp-18h],eax
 [0014] mov         dword ptr [ebp-14h],eax
 [0017] xor         eax,eax
 [0019] mov         dword ptr [ebp-18h],eax
*[001c] mov         esi,1
 [0021] xor         edi,edi
 [0023] mov         dword ptr [ebp-28h],1
 [002a] mov         dword ptr [ebp-24h],0
 [0031] inc         ecx
 [0032] mov         ebx,2
 [0037] cmp         ecx,2
 [003a] jle         00000024
 [003c] mov         eax,esi
 [003e] mov         edx,edi
 [0040] mov         esi,dword ptr [ebp-28h]
 [0043] mov         edi,dword ptr [ebp-24h]
 [0046] add         eax,dword ptr [ebp-28h]
 [0049] adc         edx,dword ptr [ebp-24h]
 [004c] mov         dword ptr [ebp-28h],eax
 [004f] mov         dword ptr [ebp-24h],edx
 [0052] inc         ebx
 [0053] cmp         ebx,ecx
 [0055] jl          FFFFFFE7
 [0057] jmp         00000007
 [0059] call        64571ACB
 [005e] mov         eax,dword ptr [ebp-28h]
 [0061] mov         edx,dword ptr [ebp-24h]
 [0064] lea         esp,[ebp-0Ch]
 [0067] pop         ebx
 [0068] pop         esi
 [0069] pop         edi
 [006a] pop         ebp
 [006b] ret
```
* <https://stackoverflow.com/q/23569160/1896169>
```
def logme(func):
    def wrapped(*args):
        for arg in args: print str(arg)
        func(*args)
    return wrapped
@logme
def my_func(*args):
    res = 1
    for arg in args :
        print "Multiplying %s by %s" % (arg, res)
        res*=arg
    print res
    return res
```
My code:
```
var abc = function(){};
display: table-*
display: table-*
display: table-*
display: table-*
display: table-*
display: table-*
display: table-*
display: table-*
+
+
+
+
+
+
+
, new {area = ""}
byte z = x + y;
byte z = x + y;
byte z = x + y;
byte z = x + y;
byte z = x + y;
byte z = x + y;
byte z = x + y;
byte z = x + y;
display: table-*
+
+
+
+
+
+
+
+
, new {area = ""}
"1,23,4"
  String[] temp = data.split("\\s+\\^,?\"'\\|+");
List<Set<Integer>> foo;
"1,23,4"
+
: base(name)
: base(name)
, new {area = ""}
, new {area = ""}
10001.10010110011
10001.10010110011
10001.10010110011
+
+
+
, new {area = ""}
"1,23,4"
  String[] temp = data.split("\\s+\\^,?\"'\\|+");
"1,23,4"
, new {area = ""}
"1,23,4"
[5326, 4223, 1204]
Runnable prs = new Runnable() {
    public void run() {
        Document doc = null;
        try {
            doc = Jsoup.connect("http://play.radio.com/").get();
        } catch (IOException e) {
            e.printStackTrace();
        }
        parser.postDelayed(prs, 10000);
    }
};
"1,23,4"
$selector.append("somestuff");
$selector.append("somestuff");
-new Date().getTimezoneOffset()/60;
: base(name)
10001.10010110011
10001.10010110011
10001.10010110011
+
+
+
 [0000] push        ebp
 [0001] mov         ebp,esp
 [0003] push        edi
 [0004] push        esi
 [0005] push        ebx
 [0006] sub         esp,1Ch
 [0009] xor         eax,eax
 [000b] mov         dword ptr [ebp-20h],eax
 [000e] mov         dword ptr [ebp-1Ch],eax
 [0011] mov         dword ptr [ebp-18h],eax
 [0014] mov         dword ptr [ebp-14h],eax
 [0017] xor         eax,eax
 [0019] mov         dword ptr [ebp-18h],eax
*[001c] mov         esi,1
 [0021] xor         edi,edi
 [0023] mov         dword ptr [ebp-28h],1
 [002a] mov         dword ptr [ebp-24h],0
 [0031] inc         ecx
 [0032] mov         ebx,2
 [0037] cmp         ecx,2
 [003a] jle         00000024
 [003c] mov         eax,esi
 [003e] mov         edx,edi
 [0040] mov         esi,dword ptr [ebp-28h]
 [0043] mov         edi,dword ptr [ebp-24h]
 [0046] add         eax,dword ptr [ebp-28h]
 [0049] adc         edx,dword ptr [ebp-24h]
 [004c] mov         dword ptr [ebp-28h],eax
 [004f] mov         dword ptr [ebp-24h],edx
 [0052] inc         ebx
 [0053] cmp         ebx,ecx
 [0055] jl          FFFFFFE7
 [0057] jmp         00000007
 [0059] call        64571ACB
 [005e] mov         eax,dword ptr [ebp-28h]
 [0061] mov         edx,dword ptr [ebp-24h]
 [0064] lea         esp,[ebp-0Ch]
 [0067] pop         ebx
 [0068] pop         esi
 [0069] pop         edi
 [006a] pop         ebp
 [006b] ret
10001.10010110011
+
: base(name)
, new {area = ""}
"1,23,4"
List<Set<Integer>> foo;
"1,23,4"
+
10001.10010110011
10001.10010110011
10001.10010110011
+
+
+
, new {area = ""}
, new {area = ""}
def logme(func):
    def wrapped(*args):
        for arg in args: print str(arg)
        func(*args)
    return wrapped
@logme
def my_func(*args):
    res = 1
    for arg in args :
        print "Multiplying %s by %s" % (arg, res)
        res*=arg
    print res
    return res
```
This works because the first `v` (in the first line) sends the IP downward. So we are basically executing this program:
```
dddddddd+++++++,bbbbbbbbd++++++++," L"+::,,111+++," ","[R           }"$$-:111+++             *                            1+:,"L "+111+++,,d     @
```
Which does this: 
* `dddddddd+++++++,` pushes `104` and prints
* `bbbbbbbbd++++++++,` pushes `101` and prints
* `" L"+,` pushes `32` and the ascii value of `L`, then adds them, duplicates twice, and prints twice
* To the one that was duplicated, `111+++,` adds 3 and prints
* `" ",` prints a space. `"[R }"$$-:111+++` pushes a `9` and duplicates it, then adds 3 to the top value
* `*` multiplies the top two values
* `1+:,` increments that number, duplicates, and prints
* `"L "+111+++,` prints `o`. `,` prints the `m` from earlier, and `d @` pushes `13` (which does nothing) and ends the program.
[Answer]
# Java
```
import java.util.*;
public class HelloMom {
     public static void main(String[] args) {
         Hashtable<String, String> ht = new Hashtable<String, String>();
        ht.put("Answer", "42");
        ht.put("Hello", "World");    // First value association for "Hello" key.
        ht.put("Hello", "Mom");      // Second value association for "Hello" key.
        for (Map.Entry<String, String> e : ht.entrySet()) {
          System.out.println(e);
        }
    }
}
```
# Output
```
Answer=42
Hello=Mom
```
There is a pesky = in there, but this is the best I could do
<https://stackoverflow.com/a/1050075/573421>
[Answer]
# C
Most of this code comes from an answer to [Find the beginning of the first word that is a palindrom](https://stackoverflow.com/a/11685575/1679849) [sic] posted by [BLUEPIXY](https://stackoverflow.com/users/971127), which outputs the word `mom`. At lines 21 and 22, the `hello` is printed by a code snippet at the end of an answer to [printf(“%%%s”,“hello”)](https://stackoverflow.com/q/5436777/1679849) by user142019 (who fortunately added a semicolon at the end), and the space between the words comes from an answer to [How to print space with padding in c](https://stackoverflow.com/a/21360942/1679849) by [M Oehm](https://stackoverflow.com/users/2979617).
### Output:
```
%hello        mom
```
I wasn't able to eliminate the extra spaces or the percent character, unfortunately :(
### Source code:
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int isPalindrome(const char *str){
    const char *front, *back;
    front=str;
    back =str + strlen(str)-1;
    for(;front<back;++front,--back){
        while(!isalpha(*front))++front;//isalnum?
        while(!isalpha(*back))--back;
        if(front > back || tolower(*front)!=tolower(*back))
            return 0;
    }
    return 1;
}
int main(){
    const char *data="Hello mom and dad, how is it going?";
    char *p, *src;
    printf("%%%s", "hello");
    printf("        ");
    p=src=strdup(data);
    for(;NULL!=(p=strtok(p, " \t\n,.!?"));p=NULL){
        if(isPalindrome(p)){
            printf("%s\n", p);
            break;
        }
    }
    free(src);
    return 0;
}
```
[Answer]
# Java
```
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Random;
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author LH
 */
public class Kopierpaste
{
    //https://stackoverflow.com/questions/15182496/why-does-this-code-using-random-strings-print-hello-world
    //randomizer code for the first String
    public static String randomString(int i)
    {
        Random ran = new Random(i);
        StringBuilder sb = new StringBuilder();
        for (int n = 0;; n++)
        {
            int k = ran.nextInt(27);
            if (k == 0)
            {
                break;
            }
            sb.append((char) ('`' + k));
        }
        return sb.toString();
    }
    public static void main(String[] nope)
    {
        //catching a System.out() based code snippet
        //https://stackoverflow.com/questions/4183408/redirect-stdout-to-a-string-in-java
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        System.setOut(new PrintStream(baos));
        //same as randomizer
        //getting hello, world inside a ByteArray
        System.out.println(randomString(-229985452) + " " + randomString(-147909649));
        
        //undo the redirecct of System.out()
        //https://stackoverflow.com/questions/4183408/redirect-stdout-to-a-string-in-java && https://stackoverflow.com/a/14716148/1405227
        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
        
        
        //stringify the out of first part
        //https://stackoverflow.com/questions/4183408/redirect-stdout-to-a-string-in-java
        String text = baos.toString();
        
        //getting rid of the world part
        //https://stackoverflow.com/a/17008136/1405227
        String firstWord = text.substring(0, text.indexOf(' '));
        //needing the word Mom
        //https://stackoverflow.com/a/8341513/1405227
        //history -> a
        String[] a = new String[]
        {
            "hey", "you", "Mom"
        };
        //stitching the array together in a certain fashion ([elem1, elem2, elem3]
        //https://stackoverflow.com/a/2822736/1405227
        //myarray->a
        String b = Arrays.toString(a);
        //getting rid of the ,s
        //https://stackoverflow.com/a/7552284/1405227 stripping annoying bullcrap out
        //result ->c
        //yourString ->b
        String c = b.replaceAll("[-+.^:,]", "");
        
        //getting the Mom] part
        //https://stackoverflow.com/a/15317037/1405227
        //sentence -> c
        String lastToken = c.replaceAll(".* ", "");
        //getting rid of more crap
        //https://stackoverflow.com/a/18599016/1405227
        //message -> lastToken
        lastToken = lastToken.replaceAll("\\W", "");
        
        //finally out
        //https://stackoverflow.com/a/19393222/1405227
        //name -> firstWord
        //income -> lastToken
        System.out.println(firstWord + " " + lastToken);
    }
}
```
Documentation and source links are in the comments ( starting with // )
clean list of sources used
* <https://stackoverflow.com/questions/15182496/why-does-this-code-using-random-strings-print-hello-world>
* <https://stackoverflow.com/questions/4183408/redirect-stdout-to-a-string-in-java>
* <https://stackoverflow.com/a/14716148/1405227>
* <https://stackoverflow.com/a/17008136/1405227>
* <https://stackoverflow.com/a/2822736/1405227>
* <https://stackoverflow.com/a/7552284/1405227>
* <https://stackoverflow.com/a/15317037/1405227>
* <https://stackoverflow.com/a/18599016/1405227>
* <https://stackoverflow.com/a/19393222/1405227>
]