[Question]
  [
You are to print this exact text:
```
ABABABABABABABABABABABABAB
BCBCBCBCBCBCBCBCBCBCBCBCBC
CDCDCDCDCDCDCDCDCDCDCDCDCD
DEDEDEDEDEDEDEDEDEDEDEDEDE
EFEFEFEFEFEFEFEFEFEFEFEFEF
FGFGFGFGFGFGFGFGFGFGFGFGFG
GHGHGHGHGHGHGHGHGHGHGHGHGH
HIHIHIHIHIHIHIHIHIHIHIHIHI
IJIJIJIJIJIJIJIJIJIJIJIJIJ
JKJKJKJKJKJKJKJKJKJKJKJKJK
KLKLKLKLKLKLKLKLKLKLKLKLKL
LMLMLMLMLMLMLMLMLMLMLMLMLM
MNMNMNMNMNMNMNMNMNMNMNMNMN
NONONONONONONONONONONONONO
OPOPOPOPOPOPOPOPOPOPOPOPOP
PQPQPQPQPQPQPQPQPQPQPQPQPQ
QRQRQRQRQRQRQRQRQRQRQRQRQR
RSRSRSRSRSRSRSRSRSRSRSRSRS
STSTSTSTSTSTSTSTSTSTSTSTST
TUTUTUTUTUTUTUTUTUTUTUTUTU
UVUVUVUVUVUVUVUVUVUVUVUVUV
VWVWVWVWVWVWVWVWVWVWVWVWVW
WXWXWXWXWXWXWXWXWXWXWXWXWX
XYXYXYXYXYXYXYXYXYXYXYXYXY
YZYZYZYZYZYZYZYZYZYZYZYZYZ
ZAZAZAZAZAZAZAZAZAZAZAZAZA
```
# Specs
* You can print all lowercase instead of all uppercase. However, case must be consistent throughout the output.
* You may print one extra trailing linefeed.
# Scoring
Since this is an alphabet wave that fluctuates to a small extent, your code should also be small in terms of byte-count. In fact, the smallest code in terms of byte-count wins.
  
[Answer]
# C, 60 bytes
```
main(i){for(;i<703;)putchar(i++%27?65+(i/27+i%27%2)%26:10);}
```
[Answer]
# Brainfuck, 104 bytes
```
>+[+[<]>>+<+]><<+++++[>+++++>>++<<<-]>[-<+++++++++++++[->>.+.-<<]>>>.<+<]<----[>+<----]>++>>+++[-<.<.>>]
```
[Answer]
## Convex, 10 bytes
```
U_(+]D*zN*
```
[Try it online!](http://convex.tryitonline.net/#code=VV8oK11EKnpOKg&input=)
```
U               Predefined Variable: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 _(+            Push a copy with the 'A at the end.
    ]           Add both strings to an array.
     D*         Repeat array 13 times. D defaults to 13.
       z        Transpose.
        N*      Join by newlines. N defaults to "\n"
```
[Answer]
## Pyth, ~~11~~ 10 bytes
```
jC*13.<BG1
```
[Try it here.](https://pyth.herokuapp.com/?code=jC%2a13.%3CBG1&debug=0)
```
        G   the alphabet
       B    bifurcate over
     .<  1  left shift by 1
  *13       repeat 13 times
 C          transpose
j           join on newlines
```
[Answer]
# Vim, ~~85~~ 83 bytes
```
:h<_<cr><cr><cr>YZZP:s/./\0\r/g<cr><c+v>ggy25Pqqlxj:let @a='xkPjj'<cr>25@akia<esc>25klq11@qh<ctrl+v>25jylpl<c+v>25jdGdd
```
I know this can be golfed more, but my head hurts so I gotta stop for now.
`<cr>` is the enter key, `<c+v>` is ctrl+v, and `<esc>` is the escape key. Those were all counted as one byte.
I recorded a gif of this, but it got screwed up. The video is fine though: <http://recordit.co/ldLKvho9Gi>
[Answer]
# Ruby, ~~42~~ ~~39~~ ~~38~~ 37 bytes
-3 bytes thanks to @user81655  
-1 byte thanks to @manatwork  
-1 byte thanks to @NotthatCharles
```
?A.upto(?Z){|a|puts (a+a.next[0])*13}
```
See it on repl.it: <https://repl.it/CmOJ>
[Answer]
# Cheddar, 48 bytes
```
print(65|>90).map(l->@"[l,l>89?65:l+1]*13).vfuse
```
Cheddar is good with strings :D
[Try it online!](http://cheddar.tryitonline.net/#code=cHJpbnQoNjV8PjkwKS5tYXAobC0-QCJbbCxsPjg5PzY1OmwrMV0qMTMpLnZmdXNl&input=)
## Explanation
```
print
  (65|>90)            // Range from 65 (A) to 90 (Z)
  .map(l->            // Map through range
    @"                // Convert following array of char codes to string
      [l,             // The character 
       l>89?65:l+1]   // See below for explanation
      *13             // Repeat 13 times
  ).vfuse             // Vertically fuse
```
What does `l>89?65:l+1` do? Well `89` is the char code for `Y`. Basically, `l>89` is checking if the letter is `Z`, that means we should be returning `A`. If `l>89` is false. I'll return `l+1`, the next char
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
26ḶḂØAṙZj⁷
```
[Try it online!](http://jelly.tryitonline.net/#code=MjbhuLbhuILDmEHhuZlaauKBtw&input=)
### How it works
```
26ḶḂØAṙZj⁷  Main link. No arguments.
26Ḷ         Yield [0, ..., 25].
   Ḃ        Bit; compute the parity of each intger.
    ØAṙ     Rotate the alphabet by these amounts.
       Z    Zip; transpose rows and columns.
        j⁷  Join, separating by linefeeds.
```
[Answer]
## Haskell, ~~60~~ 58 bytes
```
mapM putStrLn[[0..12]>>[a,b]|a:b:_<-scanr(:)"A"['A'..'Z']]
```
Starting with "A" `scanr(:)` builds the a list from the chars of `['A'..'Z']` from the right. (-> `["ABCDE...A", "BCDEF..A", ..., "XYZA", "YZA", "ZA", "A"]`). `(a:b:_)` matches the first two chars of each sublists (with at least two chars) and makes 13 copies of it. 
[Answer]
## PowerShell, 49 43 bytes
TimmyD's remix:
```
65..89|%{-join[char[]]($_,++$_)*13};"ZA"*13
```
was, 49 bytes:
```
0..25|%{(""+[char]($_+++65)+[char]($_%26+65))*13}
```
[![Example output](https://i.stack.imgur.com/G8lmn.gif)](https://i.stack.imgur.com/G8lmn.gif)
[Answer]
# Python 2, ~~70~~ ~~68~~ 54 bytes
List based solution:
```
L=map(chr,range(65,91))
for i in range(-26,0):print(L[i]+L[i+1])*13
```
But why create a list? Thanks LeakyNun:
```
for i in range(26):print(chr(i+65)+chr(-~i%26+65))*13
```
[Answer]
## [Jellyfish](https://github.com/iatorm/jellyfish), 26 bytes
```
P
+'A
~
| S
+$ r2
 ,'
r'
```
Note the trailing unprintable characters on the last two lines.
[Try it online!](http://jellyfish.tryitonline.net/#code=UAorJ0EKfgp8IFMKKyQgcjIKICwnGgpyJxo&input=)
## Explanation
This is basically an arithmetic manipulation approach: make a 26×26 grid with alternating 0-1 pattern, add the index of each row to every element of the row, reduce mod 26, and add the ASCII value of `A`.
Characters in Jellyfish are just numbers with a special flag, and all arithmetic works on them as expected.
From bottom to top:
* The `'`s are character literals; they are followed by unprintables with ASCII code 26, and stand for those characters.
* The lower `r` computes the character range from 0 to 25.
* The `,` forms a pair from the two unprintable chars.
* The higher `r` is given argument `2`, and forms the range `[0 1]`.
* The `$` takes that range, and reshapes it into the shape given by its other argument, which is the pair of unprintables. This gives a 26×26 matrix of alternating rows `0 1 0 1 0 1 ...`
* The lower `+` adds the char range 0-25 to this matrix. The addition distributes on the rows, so row **i** is incremented by **i**. It's also converted to a char matrix, since the south argument consists of chars.
* The `~|` is modulus with flipped arguments: the south argument (the above char matrix) is reduced modulo the east argument (the `S` turns the argument-seeking process south, so this is the unprintable literal 26).
* The higher `+` adds the literal `A` to every coordinate of the resulting matrix.
* The `P` prints the result in matrix format, that is, each row on its own line without quotes.
[Answer]
# R, ~~72~~ ~~67~~ ~~60~~ 56 bytes
```
write(matrix(LETTERS[c(1:26,2:26,1)],26,26,T),"",26,,"")
```
Thanks to [@Giuseppe](https://codegolf.stackexchange.com/users/67312) for the extra 4 bytes off!
Old `rep`-based solution at 60 bytes:
```
for(i in 1:26)cat(rep(LETTERS[c(i,i%%26+1)],13),"\n",sep="")
```
See [here](http://www.r-fiddle.org/#/fiddle?id=BG1LX7Mx&version=5) on an online interpreter. Thanks to [@user5957401](https://codegolf.stackexchange.com/users/58162) for the extra 7 bytes off!
Old matrix-based solution at 72 bytes:
```
for(i in 1:26)cat(matrix(LETTERS[c(1:26,2:26,1)],26,26)[i,],"\n",sep="")
```
See [here](http://www.r-fiddle.org/#/fiddle?id=BG1LX7Mx&version=1) on an online interpreter.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 13 bytes
```
1Y2tn:!to~!+)
```
[**Try it online!**](http://matl.tryitonline.net/#code=MVkydG46IXRvfiErKQ&input=)
```
1Y2    % Predefined string literal: 'AB···Z'
tn:    % Duplicate, number of elements, range: gives [1, 2, ···, 26]
!      % Transpose into a column vector
to~!   % Duplicate and transform into [0, 1, 0, 1, ···, 1] using modulo 2
+      % Addition with broadcast. Gives 2D numeric array
)      % Index (modularly) into string. Implicitly display.
```
[Answer]
# Vim, 31 bytes
```
:h<_↵↵↵YZZPJra0qqy2l13Plr↵25@qD
```
Where `↵` is the Return key.
[![enter image description here](https://i.stack.imgur.com/zDguj.gif)](https://i.stack.imgur.com/zDguj.gif)
[Answer]
## Perl, 26 bytes
*Solution from [@Dom Hastings](https://codegolf.stackexchange.com/users/9365/dom-hastings). (12 bytes shorter than mine!)*  
*-1 byte thanks to [@Ton Hospel](https://codegolf.stackexchange.com/users/51507/ton-hospel)*
```
say+($_++,chop)x13for A..Z
```
Run with `-M5.010` or `-E` :
```
perl -E 'say+($_++,chop)x13for A..Z'
```
[Answer]
**T-SQL 133 Bytes** (Golfed by : @t-clausen.dk)
```
SELECT REPLICATE(Char(number+65)+IIF(number=25,'A',Char(number+66)),13)FROM spt_values WHERE number<26and'P'=TYPE
```
**T-SQL , 151 Bytes**
Using CTE to generate sequence of number
```
;WITH n(a,v) AS(SELECT CHAR(65)+CHAR(66), 66 UNION ALL SELECT CHAR(v)+CHAR(v+1), v+1 FROM n WHERE v < 91)SELECT REPLICATE(REPLACE(a,'[','A'),13) FROM n
```
**T-SQL, 155 Bytes**
```
SELECT REPLICATE(Char(number+65)+ CASE WHEN number=25 THEN 'A' ELSE Char(number+66) END, 13) FROM master.dbo.spt_values  WHERE name IS NULL AND number < 26
```
[Answer]
# Julia, 46 bytes
```
[println("$c$(c+1-26(c>89))"^13)for c='A':'Z']
```
[Try it online!](http://julia.tryitonline.net/#code=W3ByaW50bG4oIiRjJChjKzEtMjYoYz44OSkpIl4xMylmb3IgYz0nQSc6J1onXQ&input=)
[Answer]
# Pyth, 10 bytes
```
jCm.<G~!ZG
```
[Demonstration](https://pyth.herokuapp.com/?code=jCm.%3CG~%21ZG&debug=0)
Explanation:
```
jCm.<G~!ZG
  m      G    Map over G, predefined to the lowercase alphabet.
              This will give 26 columns.
   .<G        Left shift (cyclically) G by
        Z     Z elements. Z is initialized to 0.
      ~!      After using its value, logical not Z. (0 -> 1, 1 -> 0)
 C            Transpose
j             Join on newlines
```
[Answer]
## Brainfuck, ~~88~~ 86 bytes
```
++[[+>]<+<++]+>-[[->+>+<<]>>-]++++++++[<[++++++++<+<]>[>]<-]<<++<[>+++[->.<<.>]<<++.<]
```
Requires an interpreter with 8-bit cells and a tape not bounded on the left. [Try it online!](http://brainfuck.tryitonline.net/#code=KytbWys-XTwrPCsrXSs-LVtbLT4rPis8PF0-Pi1dKysrKysrKytbPFsrKysrKysrKzwrPF0-Wz5dPC1dPDwrKzxbPisrK1stPi48PC4-XTw8KysuPF0&input=)
[Answer]
# Lua, 80 65 Bytes.
```
s = string c = s.char for i=1,26 do print(s.rep(c(64+i)..c((65+(i%26))),13)) end
```
With help from Leaky Nun
```
c=("").char for i=1,26 do print((c(64+i)..c(65+i%26)):rep(13))end
```
Lua is a pretty inefficent language in regards to handling of strings and such, so this is the best I can narrow it down.
[Answer]
## 05AB1E, 12 bytes
```
ADÀ)øvyJ5Ø×,
```
**Explanation**
```
AD            # push 2 copies of the alphabet
  À           # rotate the 2nd one left by 1
   )ø         # add to list and zip
     v        # for each
      yJ      # join the pair
        5Ø×   # repeat it 13 times
           ,  # print with newline
```
[Try it online](http://05ab1e.tryitonline.net/#code=QUTDgCnDuHZ5SjXDmMOXLA&input=)
[Answer]
# Mathematica, ~~82~~ ~~75~~ ~~67~~ 66 bytes
```
Print@FromCharacterCode@PadLeft[{},26,{i-1,i}~Mod~26+65]~Do~{i,26}
```
Technically shorter, although it prints in lowercase instead of uppercase:
# Mathematica, 64 bytes
```
Print[""<>FromLetterNumber@Table[{i-1,i}~Mod~26+1,13]]~Do~{i,26}
```
[Answer]
# TSQL, 111 bytes
```
DECLARE @o varchar(702)='',@ int=1WHILE @<702SELECT @o+=CHAR(IIF(@%27=0,10,65+(@/27+1-@%27%2)%26)),@+=1PRINT @o
```
[Fiddle](https://data.stackexchange.com/stackoverflow/query/523598/print-an-alphabet-wave)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 [bytes](https://github.com/abrudz/SBCS)
```
⍉↑26⍴⌽∘⎕A¨⍳2
```
[Try it online!](https://tio.run/##XZC7DoJAEEV7voISCgWWh7WfAjEQEwK2JlYWCBvWaIzG1kcisdXCxsZPmR/Bu4EYobjJZufM2Zn1Z/FgMvfjNKppvZ@mlG1MhfJVWJMoKNsyj8STyjflR9THn4rEg9UA6lBRkigBD1BDzZeUqNiC@Fmn8iWvlCCwQGiNBZ068QNUQ@IXsNIIhDWS32u41Sxpw0FH3Zb1/P6PZDumslELA3G6ClOV/RiWL1vAbRztIFcLcNfg9YborYw/uRmMipOBpVWshTDERhzERbwv "APL (Dyalog Unicode) – Try It Online")
Requires `⎕IO←0`, so that `⍳2` evaluates to `0 1`.
### How it works
```
⍳2     ⍝ 0 1
⌽∘⎕A¨  ⍝ Rotate the uppercase alphabet 0 and 1 times,
       ⍝ giving ["ABC..Z", "BCD..ZA"]
26⍴    ⍝ Cycle the two strings to the length of 26
⍉↑     ⍝ Promote to a matrix and transpose
```
---
## Bunch of 13- and 14-byte solutions
```
⍉↑26⍴⎕A(1⌽⎕A)
⍉↑26⍴0 1⌽¨⊂⎕A
(26⍴⍳2)⊖∘.⊣⍨⎕A
∪⍉↑26⍴↓2 27⍴⎕A
∪26⍴⍤1⍉2 27⍴⎕A
```
These are included in the TIO link above.
[Answer]
# [Brachylog v1](https://github.com/JCumin/Brachylog/releases), ~~30~~ ~~24~~ 20 bytes
```
~~@Ab:"a"c:@Arz:{:12jc:@Nc.}a:wa~~
~~@Ab:"a"c:@Arze:12jcw@Nw\~~
@A$(:@Arze:12jcw@Nw\
```
[Try it online!](http://brachylog.tryitonline.net/#code=QEEkKDpAQXJ6ZToxMmpjd0BOd1w)
[Answer]
# J, ~~20~~ 19 bytes
**1 byte thanks to miles.**
```
u:65+26|(+/2&|)i.26
```
[Online interpreter](http://tryj.tk/)
This is actually the program I used to generate the text in the challenge.
[Answer]
# Oracle SQL 11.2, ~~141~~ 138 bytes
```
SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)FROM(SELECT CEIL(LEVEL/13)l FROM DUAL CONNECT BY LEVEL<339)GROUP BY l;
```
Un-golfed
```
SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)
FROM   (
         SELECT CEIL(LEVEL/13)l 
         FROM   DUAL 
         CONNECT BY LEVEL<339  -- 26*13+1
       )
GROUP BY l                               
```
[Answer]
# T-SQL 99 90 bytes
Saved 9 bytes thanks to @t-clausen.dk
`DECLARE @ INT=65z:PRINT REPLICATE(CHAR(@)+CHAR(IIF(@=90,65,@+1)),13)SET @+=1IF @<=90GOTO z`
Ungolfed:
```
DECLARE @CurrCharacter INT = 65; --ASCII decimal for 'A'
WHILE (@CurrCharacter <=90) --ASCII decimal for 'Z'
BEGIN 
   PRINT REPLICATE(
    REPLACE(CHAR(@CurrCharacter)+CHAR(@CurrCharacter+1),'[','A')
    ,13); --Replicate the current character and its neighbor 13 times. If the neighbor is '[' (ASCII code 91) then replace it with 'A'.
   SET @CurrCharacter+=1; --Go to the next letter
END
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~11~~ 9 bytes
```
AuDÀø13×»
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fsdTlcMPhHYbGh6cf2v3/PwA "05AB1E – Try It Online")
Posting because it beats the other 05AB1E answer and kinda uses a different method
*-2 with vectorisation*
## Explained
```
Au          # Push the uppercase alphabet. STACK = [A-Z]
  D         # Duplicate that. STACK = [A-Z, A-Z]
   À        # Rotate the alphabet left. STACK = [A-Z, Rotate_Left(A-Z)]
    ø       # Zip those two alphabets. STACK = ["AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK", "KL", "LM", "MN", "NO", "OP", "PQ", "QR", "RS", "ST", "TU", "UV", "VW", "WX", "XY", "YZ", "ZA"]
     13×»   # Repeat each 13 times and join with newline
```
]