Java, 688 678 590 379 361 bytes

Returns a string.

n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")

-10 bytes by returning the raw stream (old answer)

-88 bytes by using base 10 numerics (thanks @ceilingcat!)

-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)

-18 bytes by using a different encoded integer (thanks again @JollyJoker)


Try it online!



Explanation:

n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
 .toString(3) // Re-encode as ternary
 .replace("2","0000") // Replace 2 with "0000"
 // Implicit return

Jelly, 213 bytes

“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İuy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’

Try it online!

I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.

Try it online - with further decoding to demonstrate output!

If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.

Brainfuck, 2360 2008 1938 bytes

-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...

Try it online!

I will probably golf this even further soon.

C# (Visual C# Interactive Compiler), 366 332 329 319 bytes

int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));

Replace all instances of ␀ with to test.

Try it online!

C# (Visual C# Interactive Compiler), 305 bytes, 210 chars

_=>"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))

Same with above, replace with ␀ with to test. Output as IEnumerable<string>.

Try it online!(Courtesy of Jo King)

Deadfish~, 1115 bytes

ooooooiodoiodoiodoiodoicdooiodoiodoooooiodoiodoooooooiodooicdiodoooiodoooiodoooiodooiodoioodooiodoicdiodoiodoiodoiodoiodoiodoiodoiodooiodooiodooicdoooooicdoooioodoooooooooicdoioodoiodoooooooooicdoioodoiodoooooooooicdoooooooooiodoiodoiodoooooooooicdoooooooooiooooodoooooooooicdoooooicdioodooooiooodoooioodooooioodoooicdiodooooioodooiodooooicdioodoiodoooioodoooioodooooioodoiodoicdiooooodoiooooodoiooooodoiooooodicdoooooicdoooiodooooooooiodoicdoooooicdooooiodooooooooiodicdiooooodooooiooooodicdoooooicdioodooooioodooooiooodoooioodoooicdiodoooooooiodoooooooooiodooooicdioodoiodooooioodoooiooodooioodoiodoicdiooooodoiooooodoiooooodoiooooodicdoooooicdoooiodooooooioodoooooooooiodoicdoioodooicdooooiodoooooioodoiodicdiooooodoooooioodooooooiooooodicdoioodooicdooiodooooooooiodooooooooiodooicdoooiodooooooioodoooooooiodoooicdooooioodooooioodooooooiodooooicdooooooioodoooiodooooioodoooooicdoioodooioodoooooooicdooooooioodoooiodooooioodooooo

Try it online!

If someone has the patience to golf this further, I salute you ahead of time. :P

Perl 6, 368 bytes

.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)

Try it online!

The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.

Wolfram Language (Mathematica), 383 bytes

StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]

Try it online!

Node.js, 333 bytes

Returns a binary string of 1,679 characters.

_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s

Try it online! (with formatted output)

JavaScript (ES8), 413 bytes

Returns a binary string of 1,679 characters.

_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))

Try it online! (with formatted output)

Bubblegum, 275 236 bytes

00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580  
 
 

MathGolf, 223 220 bytes

'06*"x·<×J× Ç×►B×ê"@$↕!◙è0♥f░×→0×♠p└☺α?×└•×◙×P♣p¬è:×►∟××××←♦♠♣≥â☻┘A☺▄αp⌂r☻[║►×>◘×♦♦└:☻↑`×♥@@@@►►@♦↑ ☻♀◘☻♦☻☻├×å↑×╠×Ç!♠ 0♀◘↑◘☻♦◘×♠α♥â▼ÇA×└×◘` ×××▀≈═14♦►►π0♀××°×α•×►×××☻×◘××└≈}_├↑♪↓×─0♫♥×××|××*××♪×Ç♠×└×××× ⌐¬╩↕◄○((×T☺"$à+

Try it online!

Explanation

'0 push single character "0"
 6* repeat 6 times
 "..." push the magic string
 $ convert to ordinal
 à convert to binary string
 + pop a, b : push(a+b) (add the 6 zeroes)
 below is the footer
 L/ divide into groups of 23 characters
 n join array with newlines into string

Python 2, 336 bytes

print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]

Try it online!

Prints a string of bytes

Bash, 702 697 bytes

xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X

Try it online!

Ruby, 362 bytes

puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)

Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib or base64.

Try it online!

[C++ (VC++)(but tested with gcc as well)], 585 bytes

#define l(x,y)for(int x=0;x<y;x++)
void f()const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365)int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4)if(x--)cout<<(int)((d&(8>>j))>0);

Try it online!

ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):

#include <stdio.h>
#include <iostream>
using namespace std;
int main()

 const char arecibo[]="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
 int i = 0,j;
 while (i<sizeof(arecibo)-1)
 
 char digit = arecibo[i];
 int count=0;
 if (digit >= '0' & digit <= '9')
 
 digit -= '0';
 
 else if (digit>='A'& digit<='F')
 
 digit -= 'A'-10;
 
 else if (digit > 'F'&digit<='Z')
 
 //digit does not contain any valid hex digit in this case
 count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
 digit = arecibo[i - 1];
 
 for (count; count >= 0; count--)
 
 for (j = 0; j<4; j++)
 
 cout << (int)(((digit)&(8 >> j))>0);
 
 
 i++;
 
 return 0;

as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the , Operator and the like.

Output Format is uninterrupted stream of 1679 0/1-values.

Perl 6, 348 bytes

"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)

Based on Benjamin Urquhart's Java solution.

Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.

Try it online!

Piet, 1763 codels

Outputs a stream of 0s and 1s (no line breaks).

Codel size 1:

Codel size 4, for easier viewing:

Explanation

• First, push a sentinel value of -1 onto the stack.


• Then push the Arecibo message, in reverse order (because it's a stack), using run-length encoding.


• Finally, alternate between two loops, one printing zeroes and the other printing ones.
  
  
  • The loop counter is the current stack value, decremented until it hits zero, at which point it is discarded and we switch to the other loop.
  
  
  • Between the zeroes-loop and the ones-loop, check for the sentinel value, exiting if it is found.
  
  

Notes

The program follows a spiral path, clockwise from top left into the centre. The scattered black blocks that roughly follow the diagonals are the flow control. Here's the trace from NPiet.

I've been working on this since the day this challenge went up, but it took a little bit of time to get the message "written" into the picture! I wrote the final loops and the sentinel value first, and then built up the message from the centre outwards. (Since Piet always starts execution from the top left, I expected to have to shuffle and rotate the image around to avoid excess whitespace, but it fit perfectly!)

Fun fact: Run-length encoding in Piet doesn't (by itself) save any space. It takes n codels of one colour to push the value n onto the stack, or n codels of different colours to push that many 1s onto the stack. So it's the same number of codels either way. But the bigger numbers that RLE gives you mean you can use arithmetic tricks (e.g. instead of pushing 9, you can push 3, duplicate, and multiply) to reduce the number of codels, and funny-shaped blocks to fill in available whitespace.

I wasn't sure about how to count score for Piet entries. I found some that seem to count all codels, and others that explicitly only count those actively used. I just counted them all; ignoring white codels (even those that the program never moves through) seems akin to ignoring whitespace in a more typical programming language.

Oh, and I've just now (two hours after posting) realised that I wasted the last bit of time working on this. I wanted to trim off the almost-completely-white last row and column, so I shuffled things around... including the black flow-control blocks. But the edges of the image work the same as black! If I'd just remembered that, I wouldn't have needed to spend so much time puzzling over the intricacies of DPs and CCs...