[Question]
  [
...will you help me immortalize it?
[![enter image description here](https://i.stack.imgur.com/5KcWXm.png)](https://i.stack.imgur.com/5KcWXm.png)
I've had this pillow a few years now, and apparently it's time to get rid of it. Can you please write a function or program, that I can bring with me and use to recreate this pillow whenever I want to reminisce a bit.
It must work with no input arguments. 
The output should look exactly like this (trailing newlines and spaces are OK).
```
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
This is code golf, so the shortest code in bytes win!
---
## Leaderboard
```
var QUESTION_ID=98701,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# [///](http://esolangs.org/wiki////), 116 bytes
```
/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD
```
[Try it online!](http://slashes.tryitonline.net/#code=L2EvXFxcXFxcXFxcXFxcXFxcLy8vYi9cXFxcXFxcXFxcXFxcXFxcLy9BL2FhYWFhLy9CL2JiYmJiLy9DL0FCQUJBQkFCQUJBQgovL0QvQkFCQUJBQkFCQUJBCi9DQ0NDRERERENDQ0NEREREQ0NDQ0REREQ&input=)
**Edit**: the `\\\\\\\\\\\\\\\/` and `\\\\\\\\\\\\\\\\` are actually a *single* / and \, respectively.
**Edit**: -3 because I thought of removing `i`. I think this can't be further golfed.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~18~~ 15 bytes
Code:
```
„/\5×{4Å6×»6F=R
```
Explanation:
```
„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=4oCeL1w1w5d7NMOFNsOXwrs2Rj1S&input=)
[Answer]
## Python 2, 49 bytes
```
b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6
```
Thanks to Mitch Schwartz for this clean method that saves a byte. The idea is to print four lines of `('\\'*5+'/'*5)*6`, swap the roles of slash and backslash, and then do that whole process 6 times. The two characters are stored in `a` and `b`, and swapped as `a,b=b,a`. The double-loop is double by generating the following code string, then executing it with `exec`:
```
print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;
```
---
**50 bytes:**
```
s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6
```
Makes the line string, prints it four times and then reverses it, then does that 6 times. Does so by generating the following code, then executing it:
```
print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]
```
Here are some of the iterations of my golfing:
```
for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6
for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6
for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6
for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6
for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6
for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6
for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6
for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6
print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3
for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6
a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6
s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6
s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6
a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
```
[Answer]
# 05AB1E, 15 bytes
```
„/\5×{R6×6FR4F=
```
[Try it online!](http://05ab1e.tryitonline.net/#code=4oCeL1w1w5d7UjbDlzZGUjRGPQ&input=)
Explanation:
```
„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping
```
Uses the **CP-1252** encoding.
[Answer]
# [Bubblegum](http://esolangs.org/wiki/Bubblegum), 30 bytes
```
00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......
```
Obligatory Bubblegum answer.
[Answer]
## JavaScript (ES6), ~~68~~ ~~60~~ 58 bytes
A recursive function. Several optimizations inspired from [chocochaos answer](https://codegolf.stackexchange.com/a/98720/58563).
```
f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''
```
### Demo
```
f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''
console.log(f());
```
[Answer]
# Haskell, ~~77~~ ~~70~~ 57 bytes
```
a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]
```
Boring `concat`s and `replicate`s instead of playing with sines. Old was:
```
unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
```
[Answer]
# Brainfuck, 140 bytes
```
>>>++++++++[>++++++>++++++++++++<<-]++++++++++>->----<<<<<+++[>++++[>++++++[>>.....>.....<<<-]>.<<-]++++[>++++++[>>>.....<.....<<-]>.<<-]<-]
```
:-D
[Answer]
## Pyke, 16 bytes
```
"/\"6*5m*n+4*sD3
```
After update today that allowed `"` in string literals, 17 bytes
```
"/\\"6*5m*n+4*sD3
```
[Try it here!](http://pyke.catbus.co.uk/?code=%22%2F%5C%5C%226%2a5m%2an%2B4%2asD3)
[Answer]
# Python 2, ~~86~~ ~~80~~ ~~76~~ ~~74~~ 73 bytes
```
for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]
```
Could probably golf a few more off it but it's a start.
**Edit**
Saved 6 by removing some unneeded brackets
Another 4 by using a single string and then reversing it
Thanks @Adnan. Had a late night last night and still not fully awake yet :p
-1 by moving the `*24` to the variable instead of using it twice
[Answer]
# Brainfuck, 149 bytes
```
++++++++++>++++++[>++++++++<-]>->+++++++++[>++++++++++<-]>++>+++[<<++++[<<++++++[>.....>>.....<<<-]<.>>>-]++++[<<++++++[>>>.....<<.....<-]<.>>>-]>>-]
```
[The best interpreter EVAR!](//copy.sh/brainfuck?c=KysrKysrKysrKz4rKysrKytbPisrKysrKysrPC1dPi0-KysrKysrKysrWz4rKysrKysrKysrPC1dPisrPisrK1s8PCsrKytbPDwrKysrKytbPi4uLi4uPj4uLi4uLjw8PC1dPC4-Pj4tXSsrKytbPDwrKysrKytbPj4-Li4uLi48PC4uLi4uPC1dPC4-Pj4tXT4-LV0$)
This uses 6 cells (no wrapping, no modulo). Here they are:
```
0A 00 2F 00 5C 00
```
The `00` cells are used for the loop counters. Here, the counters are filled in with initial values:
```
0A 06 2F 04 5C 03
```
The leftmost counter is for the innermost loop (yes, I use nested loops of depth 3). Please note that the 4th cell (`04` counter) is used twice, once for `/////\\\\\...`, and once for `\\\\\/////...` every time.
`0A`, `2F` and `5C` are the characters `\n`, `/` and `\`, respectively.
[Answer]
# Python 2.7 66 -> 56 -> 55 bytes
```
a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3
```
new to code golfing
```
a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
```
Thanks Stewie Griffin
Forgot a silly whitespace ;)
[Answer]
# Brainfuck, 179 bytes
```
->++++++++[-<++++++>]++>+++++++++[-<++++++++++>]++++++++++>>>>+++[-<++++[-<++++++[-<+++++[-<<<.>>>]+++++[-<<.>>]>]<<.>>>]++++[-<++++++[-<+++++[-<<.>>]+++++[-<<<.>>>]>]<<.>>>]>]
```
I know this isn't the best score in the thread but I wanted to try out brainfuck and give this a try.
**Edit:**
I must've made an error while copypasting. This version should work
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~10~~ 9 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
/５４＊╬６×３＊
```
[Try it here!](https://dzaima.github.io/Canvas/?u=LyV1RkYxNSV1RkYxNCV1RkYwQSV1MjU2QyV1RkYxNiVENyV1RkYxMyV1RkYwQQ__,v=1)
Explanation:
```
/          push "/"
 54*       extend horizontally 5 times and vertically 4 times
    ╬      quad-palindromize with 0 overlap
     6×    repeat horizontally 6 times
       3*  and again vertically, 3 times
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 24 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
(60⍴5/0 4)⊖60/⍪∊3⍴⊂4/'/\'
```
[Answer]
# Ruby, 46 bytes
Creates the following string (70 characters, one set more than needed) then alternates between sampling characters `0..59` and `5..64`from it.
```
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
```
**code and output**
```
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
**interesting mistake (a 7 instead of a 5)**
```
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
```
[Answer]
# C, ~~66~~ 61 bytes
5 bytes saved thanks to orlp.
Straightforward character by character printing. 61 characters per row, last is newline (ASCII 10) and the others alternate between `/`47 and `\` 92.
```
i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);‌​}
//call like this
main(){f();}
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~18~~ 16 bytes
```
'\/'6:&+thK5&Y")
```
[Try it online!](http://matl.tryitonline.net/#code=J1wvJzY6Jit0aEs1JlkiKQ&input=)
### Explanation
```
'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
```
[Answer]
# Pyth, 22 bytes
```
V6V4V12p*5?%+bN2\\\/)k
```
Try it [here](http://pyth.herokuapp.com/?code=V6V4V12p%2a5%3F%25%2BbN2%5C%5C%5C%2F%29k&debug=0).
Explanation:
```
V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)
```
Sorry if the explanation is a little hard to understand, but it was kinda complicated.
[Answer]
# [V](http://github.com/DJMcMayhem/V),  ~~22~~  21 bytes
**Edit** One byte won, thanks @DjMcMayhem:
```
5á\5á/05ä$4Ä5x$p4Ä3ä}
```
Changes are:
* `Y4P` -> `4Ä` Use V duplicate line instead of Vim built-in command (this will add a blank line at the end of the paragraph)
* `3äG` -> `3ä}` Duplicate the paragraph instead of the whole buffer (to avoid blank line generated by previous change)
---
**Original post**
```
5á\5á/05ä$Y4P5x$p4Ä3äG
```
[Try it online](http://v.tryitonline.net/#code=NcOhXDXDoS8wNcOkJFk0UDV4JHA0w4Qzw6RH&input=)
Decomposed like this:
```
5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~17~~ 16 bytes
```
⁾/\ẋ6Wẋ4;U$ẋ3x5Y
```
[Try it online!](http://jelly.tryitonline.net/#code=4oG-L1zhuos2V-G6izQ7VSThuoszeDVZ&input=)
Thanks to 6710 (miles) for -1 byte.
[Answer]
# [Actually](http://github.com/Mego/Seriously), 21 bytes
```
"/\"5*SR6*;4α@R4α+3αi
```
[Try it online!](http://actually.tryitonline.net/#code=Ii9cIjUqU1I2Kjs0zrFAUjTOsSszzrFp&input=)
*-1 byte from Adnan*
Explanation:
```
"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
```
[Answer]
# J, ~~31~~ ~~28~~ 19 bytes
```
4#_60]`|.\5#72$'/\'
```
## Usage
```
   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
[Answer]
# APL, 30 bytes
```
A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A
```
I'm quite new to APL, (I'm using APLX, but this should work across most implementations of APL), so this is a quite simplistic solution.
### Explanation:
```
A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation 
                          of A and the reverse of A (⊖A)
```
[Answer]
# Python 2, 63 bytes
```
a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)
```
For Python 3, do this (65 bytes):
```
a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
```
[Answer]
# [Self-modifying Brainfuck](//soulsphere.org/hacks/smbf), 91 bytes
```
>>+++[<++++[<++++++[<.....<.....>>-]<<<.>>>>-]++++[<++++++[<<.....>.....>-]<<<.>>>>-]>-]
\/
```
[Try it online!](//smbf.tryitonline.net#code=Pj4rKytbPCsrKytbPCsrKysrK1s8Li4uLi48Li4uLi4-Pi1dPDw8Lj4-Pj4tXSsrKytbPCsrKysrK1s8PC4uLi4uPi4uLi4uPi1dPDw8Lj4-Pj4tXT4tXQpcLw)
Same as my [brainfuck answer](/a/98711/41024), but uses the 3 last characters of the source code instead of generating them at runtime.
[Answer]
## Octave, ~~50~~ 48 bytes
Anonymous function:
```
@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)
```
You can try [online here](http://octave-online.net). Simply run the above command and then run the function with `ans()`.
Essentially this creates an array of the value 47 which is 4 high and 5 wide. It then creates a second array of value 92 which is the same size.
The two arrays are concatenated into a checkerboard of `[A B;B A]`. The `''` is concatenated as well to force conversion to character strings.
Finally the whole array is replicated 3 times down and 6 times across to form the final size.
---
* Saved 2 bytes, thanks @StewieGriffin
[Answer]
## PHP, ~~73~~ 69 bytes
```
for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];
```
### Demo
<http://ideone.com/z7N1Md>
[Answer]
## APL, 16
```
4⌿5/1↓⍉12 7⍴'\/'
```
Try it on [tryapl.org](http://tryapl.org/?a=4%u233F5/1%u2193%u234912%207%u2374%27%5C/%27&run)
[Answer]
# Java 7, 120 bytes
```
String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}
```
Pushed everything into one loop. Beats Brainfuck, mission accomplished.
See it online: <https://ideone.com/pZjma3>
]