text:
Christmas Cracker Mystery Calculator
The presents have been opened.  The mince-pies have been eaten.  The Star Wars have been watched.  The Christmas Season is beginning to wind down.  By now you may well have pulled a few Christmas Crackers.  If you're lucky, instead of the usual useless plastic toys, you may have won a Mystery Calculator with which you can amaze your friends and relatives.

This trick consists of 6 cards each with a 4x8 grid of numbers printed on it.  Each card contains a different subset of the integers [1,63].  The magician will ask you to pick a number from one card and keep that number secret.  The magician will then ask which cards have that number.  With that knowledge, the magician will magically be able to determine and disclose the original number guessed.

Output the full set of 6 Mystery Calculator cards exactly as follows:
 1  3  5  7  9 11 13 15
17 19 21 23 25 27 29 31
33 35 37 39 41 43 45 47
49 51 53 55 57 59 61 63
 - - - - - - - - - - -
 2  3  6  7 10 11 14 15
18 19 22 23 26 27 30 31
34 35 38 39 42 43 46 47
50 51 54 55 58 59 62 63
 - - - - - - - - - - -
 4  5  6  7 12 13 14 15
20 21 22 23 28 29 30 31
36 37 38 39 44 45 46 47
52 53 54 55 60 61 62 63
 - - - - - - - - - - -
 8  9 10 11 12 13 14 15
24 25 26 27 28 29 30 31
40 41 42 43 44 45 46 47
56 57 58 59 60 61 62 63
 - - - - - - - - - - -
16 17 18 19 20 21 22 23
24 25 26 27 28 29 30 31
48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63
 - - - - - - - - - - -
32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47
48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63

Output may or may not contain one final trailing newline.  There must be no trailing whitespace.  Each card is separated by 11 - perforations.

md5sum with final newline: 7aa2d9339b810ec62a2b90c5e11d6f4a
md5sum without final newline: e9abe4e32dca3e8fbfdaa4886fc5efd2

For those of you of more of a windows orientation, I will also allow CRLF style line endings.  In that case, the md5s are:

md5sum with final newline: e4f16ff9752eee2cedb5f97c7b5aec6d
md5sum without final newline: 78c560eed3b83513e3080117ab5dc5fa

I'm just waiting for the bubblegum answer.

@MikeBufardeci here - A mediocre 184 bytes.

Are leading spaces acceptable?

@Titus Sorry, no, md5s have been given, and additional whitespace would mess those up.

Python 2, 99 96 93 91 bytes
k=1
while 1:print('%2d '*7+'%2d\n')*4%tuple(n for n in range(64)if k&n),11/(k<32)*' -';k*=2

Exits with an error, which is allowed by default.
Try it online! or verify the MD5 hash.
How it works
After initializing k as 1, we enter an infinite loop that executes the following code.
print('%2d '*7+'%2d\n')*4%tuple(n for n in range(64)if k&n),11/(k<32)*' -';k*=2

tuple(n for n in range(64)if k&n) creates a tuple of all non-negative integers below 64 that have there jth bit set, where j is the iteration count of the loop, i.e., 2j = k.
('%2d '*7+'%2d\n')*4 first creates the format string '%2d %2d %2d %2d %2d %2d %2d \n', then repeats it four times. This is a template for each card, which pads each integer in the tuple to two characters (prepending spaces), separates each group of 8 integers by spaces, and the groups themselves by linefeeds.
Now, Python 2's print statement is a curious beast. It takes several expressions, separated by commata, and prints them one by one. It evaluates the first expression, prints it, evaluates the next expressions, prints it, etc. until no more expressions are left. Unless the last expression is followed by a comma, it appends a linefeed to it. Also, it prepends a space to all expressions, unless they are printed at the beginning of a line.
In each iteration, we first print the result of applying the format string to the tuple. We're at the beginning of a line, so no space is prepended.
Then, we (attempt to) print the result of 11/(k<32)*' -'. If k < 32, this expressions evaluates to ' - - - - - - - - - - -'. Again, we're at the beginning of a line, so no space is prepended. There is no comma after this expression, so print appends a linefeed. However, in the sixth iteration, k = 25 = 32, so trying to evaluate 11/(k<32)*' -' raises an uncaught ZeroDivisionError. This breaks out of the loop and ends the program immediately.

C (gcc), 105 bytes
o;main(i){for(;i<384;i++%64||puts(" - - - - - - - - - - -"))i&1<<i/64&&printf("%2d%c",i%64,++o%8?32:10);}

Pip, 49 48 44 bytes
43 bytes of code, +1 for -S flag.
Fi,6{IiP" -"X11P(sX2-#_._M2**iBA_FI,64)<>8}

Try it online!
Explanation
                                             s is space (preinitialized)
Fi,6{                                     }  For i in range(6):
     Ii                                      If i is nonzero (i.e. all except 1st loop):
       P" -"X11                              Print hyphens
                                 FI,64       Range(64), filtered on this function:
                          2**iBA_              2**i bitwise AND with argument (is nonzero)
                         M                   To each remaining number, map this function:
                   2-#_                        2-len(argument)
                 sX                            ^ that many spaces
                       ._                      prepended to argument
                (                     )<>8   Group list into length-8 sublists
               P                             Print (-S flag joins on space then newline)

Jelly, 27 26 bytes
Ts8GW
⁾ -ẋ11W
63RBUz0Ñ€j¢Y

Try it online! or verify the MD5 hash.
How it works
63RBUz0Ñ€j¢Y  Main link. No arguments.

63R           Range 63; yield [1, ..., 63].
   B          Binary; convert each integer to base 2.
    U         Upend; reverse the binary representations.
     z0       Zip with filler 0; transpose rows and columns, filling gaps in
              the (non-rectangular) matrix with zeroes.
       Ñ€     Map the first helper link over the new rows.
          ¢   Yield the return value of the second helper link.
         j    Join the left result, separating by the right result.
           Y  Join the results, separating by line feeds.

Ts8G          First helper link. Argument: A (array of 1's and 0's)
T             Truth; get all indices of 1's.
 s8           Split the indices into chunks of length 8.
   G          Grid; convert the 2D array into a string, separating row items
              by spaces, rows by linefeeds, and left-padding each integer
              with spaces to equal lengths.
    W         Wrap the generated string in an array.

⁾ -ẋ11W       Second helper link. No arguments.

⁾ -           Yield " -".
   ẋ11        Repeat the string 11 times.
      W       Wrap the generated string in an array.

That G builtin is seriously overpowered for this challenge. I needed about 10 bytes to do the same.

Python 2, 132 bytes
for c in range(6):s=" ".join("%2d"%n for n in range(64)if n&1<<c);print"\n".join([s[24*i:24*i+23]for i in range(4)]+[" -"*11]*(c<5))

Splitting sequences is annoying in Python.
Try it online.

Ruby, 90 bytes
1.upto(383){|i|print (j=i%64)<1?' -'*11+$/:"%2d%s"%[j,j+1&15>>i/256>0?' ':$/]*(j>>i/64&1)}

Ungolfed
Fairly straightforward. The only thing that may require additional explanation is when to follow a number with a newline rather than a space. This happens when j+1%16==0 in the first four cards and j+1%8==0 in the last two. Hence the expression 15>>i/64/4 or equivalently 15>>i/256is ANDed with j to determine whether space or newline is required.
1.upto(383){|i|                              #Count starting at 1 instead of 0 to supress - -  before 1st card
  print (j=i%64)<1?                          #j=number to consider for card. If 0,
    ' -'*11+$/:                              #print - - -... else print
     "%2d%s"%[j,j+1&15>>i/256>0?' ':$/]*     #j formatted to 2 spaces followed by a space (or if j+1 divisible by 16 or 8 depending on card, a newline.)
     (j>>i/64&1)                             #only print appropriate numbers for this card, i.e. when this expression evaluates to 1
}

JavaScript (ES6), 150 bytes

f=
_=>[1,2,4,8,16,32].map(m=>[...Array(64)].map((_,i)=>` ${i}`.slice(-2)).filter(i=>i&m).join` `.replace(/(.{23}) /g,`$1
`)).join(`
${` -`.repeat(11)}
`)
;document.write(`<pre>`+f())

Perl 6,  194 116  86 bytes
put join "\n{' -'x 11}\n",map {join "\n",.[^32].rotor(8)».fmt('%2s')},(1,3...63),(2,{|($_ X+1,4)}...*),(4,{|($_ X+1,2,3,8)}...*),(8,{|((1...7,16)X+$_)}...*),(16,{|((1...15,32)X+$_)}...*),32..63

Try it
for 1..383 {print !($/=$_%64)??"{' -'x 11}\n"!!$/+>($_/64)%2??$/.fmt('%2d')~(($/+1)+&(15+>($_/256))??' '!!"\n")!!''}

Try it
for 1..383 {$_%64||put ' -'x 11;$_+&(1+<($_/64))&&printf "%2d%c",$_%64,++$/%8??32!!10}

Try it
(check the Debug sections for the MD5 results)
The last two were inspired/transcribed from the Ruby and C implementations

05AB1E, 71 bytes
63L©DÉÏ®À2ô®ÉÏ®ÀÀÀ4ô®ÉÏ®Á8ô®ÈÏ63®Á16ô®ÈÏ63D32sŸ)˜32ôvy8ôvy.B}„ -11×})¨»

Try it online!
This approach, don't try it. Will likely delete this out of shame to be honest. Matrix manipulation is not my strong suit so I tried to brute force generate all 6 sequences and then pump them together sloppily.

TFW you see your own answer from years ago ¯＼(º_o)/¯.

JavaScript (ES6), 103 102 bytes
f=(k=1,n=z=0)=>n>>6?k>>5?'':' -'.repeat(11)+`
`+f(k*2):(n&k?(n>9?'':' ')+n+`
 `[++z&7&&1]:'')+f(k,++n)

MD5: 7AA2D9339B810EC62A2B90C5E11D6F4A
Test

f=(k=1,n=z=0)=>n>>6?k>>5?'':' -'.repeat(11)+`
`+f(k*2):(n&k?(n>9?'':' ')+n+`
 `[++z&7&&1]:'')+f(k,++n)

console.log(f())

Batch, 249 bytes
@echo off
set s=
for %%i in (1 2 4 8 16 32)do for /l %%j in (0,1,63)do call:c %%i %%j
exit/b
:c
if %2==0 if %1 gtr 1 echo  - - - - - - - - - - -
set/an=%1^&%2
if %n%==0 exit/b
set n=  %2
set s=%s%%n:~-3%
if not "%s:~23%"=="" echo%s%&set s=

Outputs a trailing CRLF.

@DigitalTrauma The best ways to try it really require Wine (http://askubuntu.com/a/54271) or that you download a VM (https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/) (I recommend you to download Windows 7 with IE8, to save space. Or try to get your hands on an Windows XP + IE6 VM that used to be available)

bash / Unix utilities, 125 124 bytes
b='- - - - ';for ((x=1;x<33;x*=2));{ for n in {0..63};{ ((x&n))&&printf \ %2d $n;};echo $b$b$b;}|fold -w24|sed -e\$d -es/.//

Edit: Removed an unnecessary ^ from the regex at the end; the regex will always match at the beginning of the line anyway.

PHP, 102 bytes
for(;$c<6;$n%32||$c+=print str_pad("
",25," -"),$n%2**$c||$b+=1<<$c)printf("
"[$n++%8]."%3d",++$b%64);

prints a leading but no trailing newline, and one leading space in each line.
Run with -nr or try it online.
For PHP<5.6, replace 2**$c with (1<<$c). PHP 5.5 could use &~1<<$c?: instead of %2**$c||.
For PHP<5.5, replace "\n"[$n++%8] with ($n++%8?"":"\n").

Dashes are one character off due to the leading space; append a space to the first str_pad parameter (insert a space before the second code line) to fix.
Removing the leading space instead requires some fiddling and three additional bytes: printf("%c%2d",$n++%8?32:10,++$b%64); and 23 instead of 25.
Turning the leading newline into a trailing one would cost another three bytes:
for(;$c<6;$n%32||$c+=print str_pad("",22," -")."
",$n%2**$c||$b+=1<<$c)printf("%2d%c",++$b%64,++$n%8?32:10);

PHP, 109 bytes
for($c=1;~$c&64;$n%32||$c<<=print str_pad("",22," -")."
",$n%$c||$b+=$c)printf("%2d%c",++$b%64,++$n%8?32:10);

matches all specs and works with all PHP versions.

Python 2, 89 bytes
i=0;exec"print('%2d '*7+'%2d\\n')*4%tuple(j for j in range(64)if j&2**i)+' -'*11;i+=1;"*6

Try it online!
Explanation:
# initialize outer counter variable
i=0
           # generate a formatting string for a single row of numbers
           # %2d will left pad an integer with spaces, up to string length 2
           # the \\n is so that exec will interpret it as a character rather than a literal line break
           '%2d '*7+'%2d\\n'
          # create a formatting string of 4 lines of 8 numbers
          (.................)*4
                               # format the string with a generated tuple of numbers that have a 1 in the current bit slot
                               # (or more literally, bitwise j AND 2^i is not zero)
                               %tuple(j for j in range(64)if j&2**i)
                                                                    # add the perforation break
                                                                    +' -'*11
     # print the generated string, then increment the counter
     print..................................................................;i+=1
# execute the following statements 6 times
exec"............................................................................."*6

Good, except the - - - separator should only appear between cards and not an extra one at the end.

@DigitalTrauma Dang, and I was SO PROUD of getting a smaller bytecount than Dennis, too. Thanks for pointing it out, tho!

05AB1E, 29 bytes
63L2вíƶ0ζε0K8ô§2j»}„ -11×¶.øý

Port from @Emigna's 05AB1E answer here, after which I added additional code to print it according to the requirements in this challenge.
Try it online or verify md5sum.
Explanation:
63L          # Create a list in the range [1,63]
   2в        # Convert each number to binary as lists of 0s and 1s
     í       # Reverse each binary list
      ƶ      # Multiply each binary digit by its 1-based index [1,length] (so [1,63])
       0ζ    # Zip/transpose; swapping rows/columns, with "0" as filler
ε            # Map each inner list to:
 0K          #  Remove all 0s
   8ô        #  Split it into (four) lists of size 8
     §       #  Cast each integer to string (bug, shouldn't be necessary..)
      2j     #  And pad leading spaces to make each string size 2
        »    #  Join the inner lists by spaces, and then all strings by newlines
}„ -         # After the map: push string " -"
    11×      # Repeated 11 times to " - - - - - - - - - - -"
       ¶.ø   # Surround it with newlines: "\n - - - - - - - - - - -\n"
          ý  # And join the mapped strings with this delimiter-string
             # (after which the result is output implicitly)

JavaScript, 234 bytes.
for(a=[[],[],[],[],[],[]],i=1;i<64;i++)for(j=0;j<6;j++)i&2**j?a[j].push(i<10?" "+i:i):0;for(j=0;j<6;j++){for(s=[],i=0;i<4;)s.push(a[j].slice(i*8,++i*8).join(" "));b=s.join(n="\n");a[j]=b.substr(0,b.length)};a.join(n+" -".repeat(11)+n)

I will write explanation later.
If console.log is required, the byte count would be 247 bytes.

Welcome to the site!  Are you putting your output in an array?  I don't know Javascript but that would require you to log since you can not output via a variable.


text:
Happy Bacon Day!
Today is Bacon Day which is probably why the name of the hat for participating today is "Mmmm Bacon". What better way to celebrate bacon day with fun filled 2d matrices made out of bacon! A  1 by 1 bacon strip is represented by this:
-----
)===)
(===(
)===)
-----

You goal here is given two coordinates in a tuple, (x, y), where x and y are nonzero positive integers, you are to create the bacon and return in some format (list, array, string).
Input and Output:
Input: (2, 1)

Output:
----------
)===))===)
(===((===(
)===))===)
----------

Input: (1, 2)

Output:

-----
)===)
(===(
)===)
-----
)===)
(===(
)===)
-----

Input: (2, 2)

----------
)===))===)
(===((===(
)===))===)
----------
)===))===)
(===((===(
)===))===)
----------

Rules:

As you can see with the second test case, if multiple pieces of bacon are stacked together, only one ----- separates with each piece of bacon above and/or below it. That means stacking bacon like this is invalid:
-----
)===)
(===(
)===)
-----
-----
)===)
(===(
)===)
-----

Standard loopholes are forbidden
The code must work for the above test cases and the following: (4, 4), (1, 6), (5, 1), (2, 3), (3, 2)
Provide an interpreter where the above test cases can be tested

Winning Criteria:
Shortest code wins! Happy Bacon Day to everyone!

This conversation has been moved to chat.

V, 28, 26, 24 bytes
Ài)³=)Y4PÒ-G.MÓ)/(
kÀäG

Try it online!
Explanation:
Ài                      " Arg 1 times insert:
  )³=)                  " ')===)'
      <esc>             " Escape back to normal mode
           Y            " Yank this line
            4P          " Paste four times
              Ò-        " Replace this line with '-'
                G.      " Repeat on the last line
                  M     " Move to the middle line
                   Ó)/( " Replace ')' with '('
k                       " Move up (to the second line)
 À                      " Arg 2 times
  äG                    " Duplicate everything up to the last line

I love how this answer is only 3 bytes longer than a single bacon :D

@FlipTack There are Newlines. It's actually 2 shorter. :P

Forgot about that! Wow, an answer that's shorter than the building blocks of the output. This is some dennis-style stuff going on.

TI-Basic, 80 bytes
This one was actually quite genius :)
":→Str0:Input :For(M,0,4Y:For(N,1,X:")===)
If not(fPart(M/4:"-----
If .5=fPart(M/4:"(===(
Str0+Ans→Str0:End:Ans+":→Str0:End

Also, for anyone wondering, in TI-Basic the colon and newline are interchangeable, and using Input with no arguments gets input by default into X and Y.

Python 2.7, 74 bytes
I'm sure this could be golfed some more, but this is what I came up with (Python's string multiplication feature sure comes in handy):
a,b=input();f="-"*5*a;d=")===)"*a;print'\n'.join([f,d,"(===("*a,d,''])*b+f

Try it here!
Ungolfed with explanation:
a,b = input()                                       # Take input from the user as a tuple
f = "-"*5 * a                                       # f is the delimiter between bacons
d = ")===)" * a                                     # 2nd and 4th lines of bacon
print '\n'.join([f, d, "(===("*a, d, ''])*b + f     # Join everything together!

Mathematica, 74 bytes
Array[b["-----",b=")===)","(===("][[#~Mod~4]]&,{4#2+1,#}]~Riffle~"\n"<>""&

Unnamed function taking two positive integer arguments and returning a string-with-newlines. A standard Mathematica approach: build a 2d array of strings using a (mod 4) chooser to cycle the strings in the vertical direction, then collapse them to a single string.

05AB1E, 32 30 bytes
Saved 2 bytes thanks to Adnan.
'-5×…)==ûÐ')'(:s)vy¹×})I.D¬)˜»

Try it online!
Explanation
'-5×                            # push "-----"
    …)==ûÐ                      # push 3 copies of ")===)"
          ')'(:s                # replace ")" with "(" in the 2nd copy
                )               # wrap in list
                 vy¹×})         # repeat each list entry input-1 times
                       I.D      # repeat list input-2 times
                          ¬     # push the first element of the list ("-----")
                           )˜   # wrap in list and flatten
                             »  # join by newline

You can replace ")===)" by …)==û :)

@Adnan: Ah of course! Thanks!

C, 91 89 bytes
i;f(w,h){w=w*5+1;for(i=0;i<w*4*h+w;++i)putchar(i%w<w-1?i/w%4?i%w%5%4?61:40+i/w%2:45:10);}

05AB1E, 25 bytes
Code:
…)==û×Ð¬'(:s)¬g'-×=¸«»²F=

Explanation:
…)==û                         # Push the string ")===)"
     ×                        # String multiply by the first input
      Ð                       # Triplicate the string
       ¬                      # Take the first character, which is a ')' and push
        '(:                   # Replace by '('
           s                  # Swap the top two elements
            )                 # Wrap everything into an array
             ¬g               # Get the length of the first element in the array
               '-×            # And repeat the character '-' that many times
                  =           # Print it without popping
                   ¸«         # Append the string of dashes to the array
                     »        # Join by newlines
                      ²F      # Second input times do...
                        =     #   Print the top of the stack without popping

Uses the CP-1252 encoding. Try it online!

Batch, 168 bytes
@set s=
@for /l %%i in (1,1,%1)do @call set s=%%s%%-___-
@set t=%s:_==%
@echo %s:_=-%
@for /l %%i in (1,1,%2)do @echo %t:-=)%&echo %t:-=(%&echo %t:-=)%&echo %s:_=-%

Rather unfortunately I can't write @echo %s:==-% otherwise that would eliminate the necessity for the second variable.

Save 2 bytes by concatenating lines 1,2 and 3,4 with &...

Python 2, 70 bytes
def f(w,h):n=4*h+1;exec"n-=1;print'-)()-===-===-===-)()'[n%4::4]*w;"*n

Thanks to @xnor for saving 4 bytes!
Try it online!

It looks like the lines don't alternate directions in your test case.

It looks like a [_::3] would be shorter.

Oh shoot, something went wrong there. Deleting until I can fix it.

That fixed my code without adding any bytes. Thanks! Let's see if I manage to deduplicate those lines again.

There's 2**n%5%3 which cycles [1, 2, 1, 0, 1, 2, 1, 0, ...]. Might that be useful?

I think that would be the same byte count. I tried -~n**3%4 before.

Python 2, 59 bytes
w,h=input()
for a in'-()('*h+'-':print(a+3*'=-'[a>')']+a)*w

Generates each line as a+b*3+a from the initial character a and the center character b (which is calculated from a). The a's cycle through '-()(', whereas b is '-' when a is '-', and '=' otherwise.

67 bytes:
w,h=input()
for a,b in['--']+zip(')()-','===-')*h:print(a+b*3+a)*w

Generates each line from its outer character a and center character b as a+b*3+a, then prints w copies of this. These cycle via a zip.

JavaScript, 132 129 121 bytes
-8 bytes thanks to @user2428118

(x,y)=>{a=b=["-----",")===)","(===(",")===)","-----"];for(i=0;++i<y;){b=[...b,...a.slice(1)]}return b.map(v=>v.repeat(x)).join(`
`)}

(x,y)=>eval('a=b=["-----",")===)","(===(",")===)","-----"];for(i=0;++i<y;)b=[...b,...a.slice(1)];b.map(v=>v.repeat(x)).join`\n`')

(x,y)=>eval('a=b=[c="-----",d=")===)","(===(",d,c];for(i=0;++i<y;)b=[...b,...a.slice(1)];b.map(v=>v.repeat(x)).join`\n`')

This can quite probably be golfed more. If you have a suggestion, please leave it in the comments.

beat me by 1 byte.. :(

@devRicher But I haven't exactly golfed mine yet. :)

@devRicher Actually I accidentally miscounted the newline. Whoops. Edit: I've beat you now.

@ericw31415 (x,y)=>eval('a=b=[d="-----",c=")===)","(===(",c,d];for(i=0;++i<y;)b=[...b,...a.slice(1)].map(v=>v.repeat(x)).joinBACKTICK NEWLINE BACKTICK;')

@user2428118 This doesn't work? I can use your array simplification though. :)

You can replace b=[...b,...a.slice(1)] by b.push(...a.slice(1)) to save 1 byte.

JavaScript (ES6), 78
(x,y,r=s=>`${s}`.repeat(x)+`
`,a=r`)===)`,c=r`-----`)=>c+r(a+r`(===(`+a+c,x=y)

Test

F=
(x,y,r=s=>`${s}`.repeat(x)+`
`,a=r`)===)`,c=r`-----`)=>c+r(a+r`(===(`+a+c,x=y)

function update() {
  var x=+X.value,y=+Y.value
  O.textContent=F(x,y)
}

update()
X<input type=number id=X value=1 min=1 oninput='update()'>
Y<input type=number id=Y value=1 min=1 oninput='update()'>

Lua, 132 bytes
a="-----"b=")===)"c="(===("w,z=io.read(),io.read()function g(f)return f:rep(w).."\n"end print((g(a)..g(b)..g(c)..g(b)):rep(z)..g(a))

Long, literal string attempt. Try it here.

Vyxal, 35 bytes
(5⁰*¤-,`)===)`⁰*:,`(===(`⁰*,,)5*¤-,

Try it Online!
Uses magic :P

Jelly, 26 bytes
4“\ḊƭVṠ’bị“-=()”s5ẋ€ḷẋµ1ịṭ

This is a dyadic link (function) that returns a 2D array.
Try it online!
How it works
4“\ḊƭVṠ’bị“-=()”s5ẋ€ḷẋµ1ịṭ  Main link. Left argument: w. Right argument: h

4                           Set the return value to 4.
 “\ḊƭVṠ’b                   Yield 366323084456 and convert it to base 4.
                            This yields [1,1,1,1,1,0,2,2,2,0,3,2,2,2,3,0,2,2,2,0].
         ị“-=()”            Index into that string, using modular 1-based indexing.
                s5          Split the result into chunks of length 5.
                  ẋ€ḷ       Repeat the characters of each chunk w times.
                     ẋ      Repeat the array of chunks h times.
                      µ     Begin a new, monadic chain. Argument: M (bacon matrix)
                       1ị   Retrieve the first line.
                         ṭ  Tack; append it to M.

GameMaker Language, 160 139 148 bytes 133 bytes
x=argument0 y=argument1*4for(m=0;m<=y;m++){for(n=0;n<x;n++){a=")===)"if !m mod 4a="-----"else if n mod 2a="(===("r+=a}r+="#"}return r

Also, before you suggest it, GML requires each part of the for loop to have a statement inside :(

C, 159 158 153 bytes
p(s,n){printf(s,--n?p(s,n):0);}i,j;b(n,m){p("-----",n);for(j=3;j--;){p("\n",1);for(i=n;i--;)p(j%2?"(===(":")===)",1);}p("\n",1);--m?b(n,m):p("-----",n);}

Call with:
int main()
{
    b(2,3);
}

Nice to see another answer in C, but it can be done quite a bit shorter, see my answer :)

Tcl, 91 bytes
time {time {append h -----
append l )===)
append p (===(} $m
puts "$h
$l
$p
$l"} $n
puts $h

Try it online!

Do I need the put the input part? To account for the byte count?

C#, 160 bytes
x=>y=>{int i=0,h=4*y+1,j;var s=new string[h];for(;i<h;++i)if(i%4<1)s[i]=new string('-',x*5);else{var c=i%2>0?')':'(';for(j=0;j++<x;)s[i]+=c+"==="+c;}return s;};

Formatted version:
x => y =>
{
    int i = 0, h = 4 * y + 1, j;

    var s = new string[h];

    for (; i < h; ++i)
        if (i % 4 < 1)
            s[i] = new string('-', x * 5);
        else
        {
            var c = i % 2 > 0 ? ')' : '(';

            for (j = 0; j++ < x; )
                s[i] += c + "===" + c;
        }

    return s;
};

Try it online! (for some reason this link gives an error but works anyway)

Dart, 125 117 bytes
(x,y){var t='-'*5*x,i=0;return()sync*{yield t;for(;i<y*4;i++)yield i%4>2?t:i%2>0?'(===('*x:')===)'*x;}().join('\n');}

Try it here!

Dyalog APL, 55 bytes
This is my first time using Dyalog APL, so I'm sure this isn't the best approach.
 {(⊂'-----'),[1]⍉⍺(4×⍵)⍴')===)' '(===(' ')===)' '-----'}

Explanation: This is a quite simple approach, for a bacon grid of N×M, I make an N×(4M) matrix of the following four strings, repeating:
')===)'
'(===('
')===)'
'-----'

Then I concatenate the string ----- to the beginning.
Here's a quick explanation of the code:
')===)' '(===(' ')===)' '-----'  ⍝ An array of the four strings

⍺ (4×⍵) ⍴                        ⍝ reshape (⍴) the array to a matrix with the dimensions
                                 ⍝ ⍺ by (4×⍵) (⍺ is the 1st argument and ⍵ is the second)

⍉                               ⍝ transpose the matrix

,[1]                             ⍝ concatenate to beginning of the matrix...

(⊂'-----')                       ⍝ ...the string '-----' embedded in its own matrix (⊂)

PowerShell, 64 bytes
param($x,$y)-split'----- )===) (===( )===) -----'*$y|gu|%{$_*$x}

Try it online!

source: Stack Exchange

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

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

sort: votes


text:
Make an interweaving quine
Your task is to create a program that, when run, returns itself as output (this is known as a quine). However, this quine must, when it is copied n times, returns the quine, but with each of its characters duplicated in place n times, where n is a positive integer.
If your original program is Derp:
Derp -> Derp (must return itself as output to be a quine)

DerpDerp -> DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -> DDDeeerrrppp
etc. etc.

Keep in mind you're allowed to have whitespace in your "base" program, but they are counted when "interweaving". Say your program is
Derp
{newline}

(The newline signifies a trailing newline, and there's an extra space after the Derp). When duplicated to become
Derp
Derp
{newline}

You must output
DDeerrpp
{newline}
{newline}

Keep in mind that there's 2 extra spaces after the DDeerrpp.
Rules and Specs:

Your program must contain at least two distinct characters (which implies that your code must be at least 2 bytes long).
Standard quine rules apply.

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

"Standard rules apply" - does that mean no reading the source code?

@FlipTack It does mean that - read the link for more information.

Fission, 6 bytes
'!+OR"

Try it online! Try two copies! Try three!
Explanation
This is just the Fission standard quine. It happens to work for this challenge, because Fission has explicit entry points into the program. In particular, by duplicating the program, we add another R which adds another atom (instruction pointer). Since the source code is toroidal, the effective code being executed doesn't change otherwise — to each atom, the code still looks the same locally. However, the atoms are executed in lock step, so that the things they print are interleaved and we get an additional copy of each character in the output.
For completeness' sake I'll just shortly reiterate how the program itself works. Regardless of whether we repeat the program or not (e.g. '!+OR"'!+OR"'!+OR"), each atom sees the following code:
R"'!+OR"'!+O

The " toggles string printing mode, so that the program starts by printing '!+OR directly to STDOUT, which is all of the quine except the quote. Then '! sets the atom's mass to the character code of !, + increments it, which gives ", and O prints it while simultaneously destroying the atom. The program then terminates, because there are no atoms left.

Python 2.7, 377 310 304 194 191 bytes!
This is my first golf, so I didn't expect it to be too good. But I thought the concept in the solution I came up with was somewhat funny, so I'm posting it anyway.
def f():
 import threading as T,inspect as i;global t,a,i
 try:t.cancel()
 except:a=0
 a+=1;t=T.Timer(1,d);t.start()
def d():print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")
f()

Indeed, this is a quine; you can try it here. It abuses the inspect module pretty hard.
If we try running it with the same source code x2, we get the right output as well; you can try that here. x3, x4, etc. all work as expected.
Ungolfed with explanation:
def f():                                   # Defines a central function f
    import threading as T,inspect as i     # Imports threading and inspect
    global t,a,i                           # Global vars
    try:
        t.cancel()                         # Tries to cancel Timer from previous code
    except:
        a = 0                              # Reached when code is 1st copy; initializes a.
    a += 1                                 # a++; this is the number of copies thus far.
    t = T.Timer(1,d)               # Creates, then starts a timer to call function
    t.start()                              # d in 1 second.

def d():                                   # Prints out the source code; the quine part.
    print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")

f()                                        # Calls f()!

Isn't this a cheating quine, as it reads the source code of its own functions using inspect? (see relevant meta post). On PPCG we have specific definitions of what makes a quine valid, and 'reading the source' is usually regarded as cheating.

@FlipTack I'm not sure inspecting a function is the same as reading the source code. Quines in JavaScript and stack-based languages do this all the time.

Ok :). I've added syntax highlighting for your post. Nice idea using threading!

import threading,inspect as i can be import threading as T,inspect as i

@FlipTack Oops, thank you.

@nedla2004 Thank you for 3 less bytes ;)

CJam, 19 bytes
{]W=s"_~"+T):Te*}_~

Try it online!
How it works
{               }_~  Define an anonymous code block (function).
                 _~  Push a copy, and execute the copy.
 ]W=                 Wrap the entire stack in an array and select its last element.
                     This discards whatever was on the stack before the original
                     code block, which is needed for subsequent iterations.
    s"_~"+           Cast the code block to string, push "_~", and concatenate.
                     This pushes the stringified source code on the stack.
          T):T       Push T (initially 0), increment it, and save the result in T.
              e*     Repeat each character in the stringified source code T times.

What... how... so fast... please explain the code, so you can teach me the ways of CJam.

@Qwerp-Derp I've added an explanation.

RProgN, 66 bytes
Significant Whitespace be the death of me
[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R

Explained
[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R   #
[                                                                   # Pop whatever is already on the stack, if anything.
  "[ %q ] F 0 1 + `0 = `. { 0 m } R "                               # This string contains basically the entire function.
                                      ] F                           # ] F duplicates the string, and then F formats it, which in this case puts the first string into the second at %q, surrounded by qoutes.
                                          0 1 + `0 =                # I needed an Incrementer, so I chose 0. 0, is conveniently, pre initilized at 0. And because RProgN is horrifying, you can remap the number functions as they're just more variables. So this increments 0 every time the group is called.
                                                     `. { 0 m } R   # Replace each character with itself repeated '0' times. Because '0' is an incrementer, each time the script is called, the amount of times the characters are repeated increase.

Good lord I'm a monster...
Try it online!

Also, although ~["[%q]F01+\0=`.{0m}R"]F01+`0=`.{0m}R` works fine in generally, it's not a valid solution, because there is no way to replicate the ZSS marker.

Python 3, 122 121 112 bytes
s='try:from atexit import*;n+=1\nexcept:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])';exec(s);

Try It Online: one copy | two copies | three copies | four copies, with automatic verification
How it works
This uses the standard Python quine: Store the code you want to execute in a variable (as a string); include some logic in that string to print itself, everything before it, and everything after it; then execute that string.
The code that is executed via the string s is the following.
try:from atexit import*;n+=1
except:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])

The first line unconditionally imports the atexit module, which will allow us to register an exit handler. Trying to import the same module multiple times doesn't affect the script in any way. Then it tries to increment the variable n, to keep track of how many copies of the source code were executed.
The second line is executed only if the first one contains an error. This will be the case in the first iteration, since n is still undefined. In this case, we initialize n as 1 and register a lambda that performs the actual magic.
The registered exit handler
lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s]

will be called right before the program finishes. The lambda itself creates the string "s=%r;exec(s);"%s – %r creates a string representation of the right argument (s), which includes everything between the single quotes and the quotes themselves – then iterates over its characters. For each character c, we simply print n copies of c. Passing c*n as the named argument end to print means that no linefeed will be appended.

Python 3.8 (pre-release), 68 bytes
for c in(s:='for c in(s:=%r)%%s:\n print(end=c)#')%s:
 print(end=c)#

Try it online!
How it works:

Based on the quine print((s:='print((s:=%r)%%s)')%s)
when repeated multiple time, the code become something like:

for c in "string for the quine":
 print(end=c)#comment
 print(end=c)#comment
 print(end=c)#

Perl 5, 107 bytes
$_=q[$_=q[S];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}

Ungolfed:
$_ = '...INSERT_SOURCE_HERE...';      # Standard quine
s/INSERT_SOURCE_HERE/$_;
$a++;                                 # Count the number of repetitions
END {
    s/./$&x$a/eg;                     # Interweave
    print if $a;                      # Print...
    $a=0;                             # ...but only once
}

Try it online!

CJam, 14 bytes
{s"_~"+]:.+}_~

Try it online!
Explanations
{s"_~"+]:.+}_~
{s"_~"+    }_~ Basic quine operator.
       ]:.+    Append each character to corresponding element of the previous result if existed.

Vyxal D, 18 bytes
`£_›:¥q\`:Ė\`+•`:Ė

Try it Online! | Try it Double! | Try it x5!
`              `:Ė # Evaluate the following piece of code on itself:
 £                 # Store (itself) to the register
  _                # Pop
                   # The previous copy (if there is one) will've left its code on top of the stack; we don't want that, so we pop it
                   # This exposes the counter to the top of stack
   ›:              # Increment the counter
     ¥             # Push the code
      q            # Unevaluate (stringify) it
       \`:Ė\`+     # Append an eval (this is the quine bit)
              •    # Repeat each character (counter) times
                   # Now [counter, output] is left on the stack

Vyxal D, 25 bytes
`q\`:Ė\`+$:["21/÷Y∑|_]`:Ė

Try it Online!
A quite neat solution that interleaves its code with the previous iteration
`                     `:Ė # Evaluate on itself...
 q\`:Ė\`+                 # Quine part - uneval, append code to eval
         $                # Get the previous code
          :[              # If it exists (There's a copy of the code before it)
            "21/          # Divide each into 21 pieces
                ÷Y        # Interleave them
                  ∑       # Summate
                   |_]    # Else (If this is the first copy) pop (the 0 on top) leaving the source

Vyxal D, 8 bytes
`I!•`I!•

Try it Online! |
Try it Online!Try it Online! |
Try it Online!Try it Online!Try it Online!
Explanation
`I!•`    # push `I!•` to the stack => [ I!• ]
     I   # quote and prepend => [ `I!•`I!• ]
      !  # push the len of the stack => [ `I!•`I!• , 1 ]
       • # duplicate each char of the string by => [ `I!•`I!• ]
         # implicit output

# each time the program repeat, the length of the stack increment and the end become :

      !  # push the len of the stack => [ `I!•`I!• , `I!•`I!• , 2 ]
       • # duplicate each char of the string by => [ `I!•`I!• , ``II!!••``II!!•• ]
         # implicit output the top element of the stack

Vyxal D, 11 bytes
`q‛:Ė+!•`:Ė

Try it Online! |
Try it Online!Try it Online! |
Try it Online!Try it Online!Try it Online!
Explanation :
`q‛:Ė+!•`   # push `q‛:Ė+!•` to the stack => [ q‛:Ė+!• ]
         :  # duplicate the element on top of the stack => [ q‛:Ė+!• , q‛:Ė+!• ]
          Ė # pop and execute the element on top of the stack => [ q‛:Ė+!• ]
 q          # quote => [ `q‛:Ė+!•` ]
  ‛:Ė+      # add `:Ė` to the top of the stack =>  [ `q‛:Ė+!•`:Ė ]
      !     # push the len of the stack => [ `q‛:Ė+!•`:Ė , 1 ]
       •    # multiply each char by => [ `q‛:Ė+!•`:Ė ]
            # implicit output

# each time the program repeat, the length of the stack increment and the end become :

      !     # push the len of the stack => [ `q‛:Ė+!•`:Ė , `q‛:Ė+!•`:Ė , 2 ]
       •    # multiply each char by => [ `q‛:Ė+!•`:Ė , ``qq‛‛::ĖĖ++!!••``::ĖĖ ]
            # implicit output

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