2 added even better versions

## New: Even shorter versions!

Using encoded user paths, I have managed to reduce the program size by a few bytes. Each of these programs is equivalent to the first one, producing identical output:

92 bytes:

hexdump -C euro.ps
00000000  68 20 88 78 92 36 92 38  92 8b 88 4b 88 3c 92 ad  |h .x.6.8...K.<..|
00000010  7b 7b 88 b5 88 c4 88 2d  88 3c 30 20 30 88 3c 88  |{{.....-.<0 0.<.|
00000020  2d 88 cf 30 20 30 88 32  88 d8 88 28 88 b9 88 fb  |-..0 0.2...(....|
00000030  88 b5 88 f1 88 13 88 f1  88 17 88 fb 88 b9 88 0f  |................|
00000040  88 b5 35 88 1b 35 88 1f  88 0f 7d 8e 0b 00 07 08  |..5..5....}.....|
00000050  0a 01 23 03 0a 01 23 03  0a 7d 92 b3              |..#...#..}..|
0000005c


Which is equivalent to:

h 120 div dup scale
75 60 translate
{
{-75 -60 45 60
0 0 60 45 -50
0 0 50 -40 40
-71 -5
-75 -15
19 -15
23 -5
-71 15
-75 5
27 5
31 15}
<00 07 08 0A 01 03 03 03 0A 01 03 03 03 0A>
} ufill


And a slightly counterintuitive confusing solution saves one more character, for only 91:

$hexdump -C euro.ps 00000000 68 20 88 78 92 36 92 38 92 8b 88 4b 88 3c 92 ad |h .x.6.8...K.<..| 00000010 5b 5b 8e 1e b5 c4 2d 3c 00 00 3c 2d ce 00 00 32 |[[....-<..<-...2| 00000020 d8 28 b9 fb b5 f1 13 f1 17 fb b9 0f b5 05 1b 05 |.(..............| 00000030 1f 0f 7b 92 38 88 7f 92 50 7b 32 35 36 92 a9 7d |..{.8...P{256..}| 00000040 92 54 7d 92 49 5d 92 32 8e 0b 00 07 08 0a 01 23 |.T}.I].2.......#| 00000050 03 0a 01 23 03 0a 5d 92 32 92 b3 |...#..].2..| 0000005b  Which is equivalent to: h 120 div dup scale 75 60 translate [ [ <b5 c4 2d 3c 00 00 3c 2d ce 00 00 32 d8 28 b9 fb b5 f1 13 f1 17 fb b9 0f b5 05 1b 05 1f 0f> {dup 127 gt {256 sub} if} forall ] cvx <00 07 08 0A 01 23 03 0A 01 23 03 0A> ] cvx ufill  ## New: Even shorter versions! Using encoded user paths, I have managed to reduce the program size by a few bytes. Each of these programs is equivalent to the first one, producing identical output: 92 bytes: hexdump -C euro.ps 00000000 68 20 88 78 92 36 92 38 92 8b 88 4b 88 3c 92 ad |h .x.6.8...K.<..| 00000010 7b 7b 88 b5 88 c4 88 2d 88 3c 30 20 30 88 3c 88 |{{.....-.<0 0.<.| 00000020 2d 88 cf 30 20 30 88 32 88 d8 88 28 88 b9 88 fb |-..0 0.2...(....| 00000030 88 b5 88 f1 88 13 88 f1 88 17 88 fb 88 b9 88 0f |................| 00000040 88 b5 35 88 1b 35 88 1f 88 0f 7d 8e 0b 00 07 08 |..5..5....}.....| 00000050 0a 01 23 03 0a 01 23 03 0a 7d 92 b3 |..#...#..}..| 0000005c  Which is equivalent to: h 120 div dup scale 75 60 translate { {-75 -60 45 60 0 0 60 45 -50 0 0 50 -40 40 -71 -5 -75 -15 19 -15 23 -5 -71 15 -75 5 27 5 31 15} <00 07 08 0A 01 03 03 03 0A 01 03 03 03 0A> } ufill  And a slightly counterintuitive confusing solution saves one more character, for only 91: $ hexdump -C euro.ps
00000000  68 20 88 78 92 36 92 38  92 8b 88 4b 88 3c 92 ad  |h .x.6.8...K.<..|
00000010  5b 5b 8e 1e b5 c4 2d 3c  00 00 3c 2d ce 00 00 32  |[[....-<..<-...2|
00000020  d8 28 b9 fb b5 f1 13 f1  17 fb b9 0f b5 05 1b 05  |.(..............|
00000030  1f 0f 7b 92 38 88 7f 92  50 7b 32 35 36 92 a9 7d  |..{.8...P{256..}|
00000040  92 54 7d 92 49 5d 92 32  8e 0b 00 07 08 0a 01 23  |.T}.I].2.......#|
00000050  03 0a 01 23 03 0a 5d 92  32 92 b3                 |...#..].2..|
0000005b


Which is equivalent to:

h 120 div dup scale
75 60 translate
[
[
<b5 c4 2d 3c
00 00 3c 2d ce
00 00 32 d8 28
b9 fb
b5 f1
13 f1
17 fb
b9 0f
b5 05
1b 05
1f 0f> {dup 127 gt {256 sub} if} forall
] cvx
<00 07 08 0A 01 23 03 0A 01 23 03 0A>
] cvx
ufill

1

# PostScript/GhostScript, 100

(96 for the program, 4 for the command-line switch prefix)

Fully golfed and hand-tokenized:

\$ hexdump -C euro.ps
00000000  68 20 88 78 92 36 92 38  92 8b 88 4b 88 3c 92 ad  |h .x.6.8...K.<..|
00000010  88 00 88 00 88 3c 88 2d  88 ce 92 05 88 00 88 00  |.....<.-........|
00000020  88 32 88 d8 88 28 92 06  92 16 88 b9 88 fb 92 6b  |.2...(.........k|
00000030  88 b5 88 f1 92 63 88 13  88 f1 92 63 88 17 88 fb  |.....c.....c....|
00000040  92 63 92 16 88 b9 88 0f  92 6b 88 b5 88 05 92 63  |.c.......k.....c|
00000050  88 1b 88 05 92 63 88 1f  88 0f 92 63 92 16 92 42  |.....c.....c...B|
00000060


You can get a copy here, for your own viewing.

After seeing @ThomasW's answer, and considering my program carefully, I realized that I could do it even better.

The tokenized version is equivalent to this:

h 120 div dup scale
75 60 translate

0 0 60 45 -50 arc
0 0 50 -40 40 arcn
closepath

-71 -5 moveto
-75 -15 lineto
19 -15 lineto
23 -5 lineto
closepath

-71 15 moveto
-75 5 lineto
27 5 lineto
31 15 lineto
closepath

fill


An explanation of the optimizations:

First off, I converted my first solution into a union of some simpler subpaths, rather than one path circumscribing the entire thing. I borrowed Thomas's method of inputting a parameter, which is much better than what I had had.

Then I multiplied all the coordinates by 10 and rounded everything off to give me just integer coordinates. I also rounded off the angles, and converted the two large ones to equivalent negative angles. This conveniently makes every single number fall between -128 and 127.

And then I tokenized everything. Each operator can be represented with a two-byte sequence each. And because each number can be represented by a single signed byte, each one also becomes only two bytes. The only part I couldn't do that with was the h at the start, but it too is only two bytes, just the h and a space after it.

Run it as:

gs -dh=200 euro.ps


gs -dh=80 euro.ps


gs -dh=20 euro.ps