PNG, 96 bytes

After reading this article and becoming more familiar than I would ever want to with these docs, I've created a PNG solution. It's definitely not optimal. I haven't quite figured out the compression entirely yet. Anyway, here it is:

00000000: 8950 4e47 0d0a 1a0a 0000 000d 4948 4452  .PNG........IHDR
00000010: 0000 004e 0000 0034 0103 0000 001e dd9c  ...N...4........
00000020: f900 0000 0650 4c54 4500 57b7 ffd7 00df  .....PLTE.W.....
00000030: 10bb 0200 0000 1549 4441 5478 da63 6018  .......IDATx.c`.
00000040: 0578 c07f 18f8 33ca c460 0200 8b3d 02be  .x....3..`...=..
00000050: 44c1 a979 0000 0000 4945 4e44 ae42 6082  D..y....IEND.B`.

I'd recommend downloading it and checking it out on this useful page which shows the structure: https://evanhahn.gitlab.io/png-explorer/

It's also linked from the first article.

In summary, it contains these chunks. You can see them in the ASCII decoding of the bytes.

• PNG A signature chunk saying it's a PNG file
• IHDR A header chunk with the width, height and colour type, and some other stuff. This image is "index color", meaning it has a palette of colours which it picks from for each pixel.
• PLTE A palette chunk containing the two colours. You can see these in the bytes near the end of the third line as 4500 57b7 ffd7 00df, which is the two hex colours next to each other.
• IDAT The image data chunk itself (this is a scanline for each row, which is either zeros or ones depending if it's blue or yellow). It is compressed losslessly.
• IEND An "end" chunk

Some optimisations to be had:

• The end chunk seems to be able to be removed, although this is in violation of the spec. Saves 12 bytes.
• The article also links to this website which allows you to generate a single colour image. It somehow has better compression and I couldn't get my zlib to do it. It saves about 4 bytes.

So it's probably possible to get down to 80 bytes quite easily. Beyond that:

• You could probably use the background colour and omit half the scanlines. Again, this would probably be in violation of the spec. It also may actually use more bytes.
• You may be able to use pixel aspect ratio to use less pixels

Here's the awful code I threw together to create it: https://pastebin.com/tjdrQ4md

HTML, 71 bytes

<svg viewBox=0,0,1.5,1 style=background:gold><line stroke=#0057b7 x2=3>

Vyxal Ḣs, 33 bytes

»ƛ∨ɖoʀĊ∩»H½4εfƛ`<¦₴ «⟇=øḢ-÷¥:#Π>.

Try it Online! The aspect ratio is a little weird and subject to Vyxal's default window sizing, but this is pretty much 3:2. You can fiddle with the 4 to change the height.

»...»H½                       # Compressed integer converted to hexadecimal and cut in half - FFD700 and 0057B7
       4εf                    # Repeat each four times
          ƛ                   # Format each into 
           `<¦₴ «⟇=øḢ-÷¥:#Π>. # Compressed string "<div style=background-color:#%>."
                              # (s flag) concatenate
                              # (Ḣ flag) render as HTML

Uiua, 36 bytes

&ims÷255⊂∩(↯26↯78)0_87_183 255_215_0

Try it in the pad!

Explanation

0_87_183 255_215_0: Push the RGB values on the stack

∩(…): Apply this function to both values:

• ↯26↯78: Reshape them so they become stripes

&ims÷255⊂: Join them together and divide by 255, then show as an image

Actionscript 3, 94 89 bytes

Here comes our national flag in Actionscript and this is my first submission in this language, since my usual languages have been already taken. The code throws an error, but it will compile a SWF (a "swiff") anyway. I took the inspiration from a similar answer to another challenge.

• spared 5 bytes by replacing hexadecimal 0xe0057B7 for 22455 and 0xeffd700 for 16766720.

var g=graphics,f=g.beginFill,r=g.drawRect
f(22455);r(0,0,99,33)
f(16766720);r(0,33,99,33)

Glory to Ukraine!

Uiua^SBCS, 31 34 bytes

&ims≡↯78▽26÷255⊟0_87_183 255_215_0

Try it here!

Explanation

&ims≡↯78▽26÷255⊟0_87_183 255_215_0
               ⊟0_87_183 255_215_0 blue and yellow
           ÷255                     divide each element by 255 so the flag shows correctly
        ▽26                         repeat each element 26 times
    ≡↯78                            turn the elements into rows
&ims                                display image to work on terminals

JavaScript (Node.js), 76 74 bytes

for(i=o=[];i<2400;i++)o+=i%60?[...'🟦🟨'][i/1200|0]:`
`;console.log(o)

Try it online!

Octave, 55 47 bytes

imagesc([5 5 5;4 4 4],[3,5])
colormap(prism(5))

My first time posting in Octave! There might be a way to display without having to use climits, or maybe even without changing the default colormap, but I have not found it yet.

Credits to cnln for the save!

Python 3, 152 bytes

A repurposing of my answer to the Pride flag challenge, with some small improvements to the visuals.

from curses import*
s=initscr();start_color();y=1
for x in[12,11,0]:w=newwin(13,78,~-y*13,0);init_pair(y,1,x);w.bkgd(' ',color_pair(y));w.refresh();y+=1

JSL (JMP Scripting Language), 110 bytes

NewWindow("",Graph(FillColor({1,43/51,0});Rect(0,33,99,66,1);FillColor({0,29/85,183/255});Rect(0,66,99,99,1)))

SVG - Scalable Vector Graphics. 151 bytes

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 3 2"><path d="M0 0H3V1H0ZM0 1H3V2H0Z" fill="#005BBB"/><path d="M0 1H3V2H0Z" fill="#FFD500"/></svg>

Try it online

Excel VBA, ₈₄ 66 Bytes

Anonymous function that takes no input and outputs to the range A1:NH830. Cell sizes are not adjusted, rather the cell that are selected are adjusted to account for the \$\approx415:124\$ default cell aspect ratio.

[A1:NH830].Interior.Color=55265:[A1:NH415].Interior.Color=12015360

Output

J + viewmat, 33 bytes

viewrgb 52 78$2028#22455 16766720

viewrgb 52 78$2028#22455 16766720
              2028#22455 16766720  NB. repeat color values 26*78 times
        52 78$                     NB. shape that into a matrix
viewrgb                            NB. draw the colors

J, 52 bytes

viewrgb 52 78$22455,&:(2028&$)16766720[load'viewmat'

viewrgb 52 78$22455,&:(2028&$)16766720[load'viewmat'
                                       load'viewmat'  : loads the lib into the session
                                      [               : acts as a statement seperator
              22455,&:(2028&$)16766720                : array of color values
                   ,&:(2028&$)                        : append,appose,shape bonded with
                                                      : 2028 as the left arg which
                                                      : invokes shape on the two args
                                                      : individually and invokes append
                                                      : on the results
        52 78$                                        : creates the color matrix
viewrgb                                               : draw the colors

Prism v0.2a, 5 bytes

Prism is a small esolang I developed in the last couple of days.

It's not (yet) available as a pre-compiled executable, so you'll have to compile it yourselves to test this program.

Anyway, since 80% of the bytes in this program aren't printable characters, here is a hexdump of the program, made with xxd -g 1:

00000000: c0 aa 58 02 9e                                   ..X..

The program does two things:

1. It resizes the canvas and the window from the default 256x256 to 256x170;
2. It draws two horizontal stripes with 4-bit colors 9 and e.

As of version 0.2a, Prism only supports 4-bit colors, and thus I picked the two aforementioned colors as they were the closest available.

You can run this program (or any other Prism program) by using prism draw <filename>.

Chipmunk BASIC, 116 bytes

Chipmunk Basic v368b2.02 on MacOS. This fun wee lang adjusts RGB values by a factor0.392157.

graphics 0
graphics color 0,34,72
graphics fillrect 0,0,132,44
graphics color 100,84,0
graphics fillrect 0,44,132,88

HTML, 200 Bytes

<mark style="background-color:blue"id="a"></mark><mark id="b"></mark><script>document.getElementById("a").innerHTML=document.getElementById("b").innerHTML=(" ".repeat(78)+"<br>").repeat(26)</script>

Those poor Ukrainians... 😔

You should click on the link to render the full page after running the code.

Prints the Ukrainian flag (although it's missing a trident unfortunately) using <mark> tags to render the colours. Uses a script to insert the text. Uses U+2001 EM QUAD as a blank character.

Minecraft Function, 58 Bytes

fill 1 1 1 78 26 1 yellow_bed
fill 1 27 1 78 52 1 blue_bed

Creates the Ukrainian flag using blue and yellow beds. Go to the coordinates 0, 0, 0 and it should be visible. I recommend running it in a flat/superflat world with version 1.18 or later.

Image

Scratch, 155 bytes

when gf clicked
set pen color to(()+(22455
set pen size to(800
pen down
go to x:(-240)y:(-90
set pen size to(180
set pen color to(()+(16766720
set x to(240

Try it online! | Test it on Scratchblocks!

Explanation

So basically:

1. When the green flag is clicked, the program sets the pen color to ()+(22455), because the set pen color to block doesn't support bare numbers, so we have to do:
   [nothing, evaluates to 0]+22455
22455 is the Scratch color value of RGB(0, 87, 183) (blue).
2. Then the pen size is set to 800, which is just a big number
3. After executing pen down, the pencil goes to x:-240, which is the leftmost pixel, and to y:-90 (the starting point for the bottom part). As it goes, the pencil draws a big blue blob which fills out the entire screen.
4. The pen size is set to 180, half of the window height.
5. The pen color is set to ()+(16766720, the scratch color value for RGB(255, 215, 0) (yellow).
6. Finally, with setting x to 240, the program draws the bottom "line".

Nim + pixie, 139 bytes

import pixie
let
 i=78.newImage 52
 c=i.newContext
i.fill rgb(0,87,183)
c.fillStyle=rgb(255,215,0)
c.fillRect 0,26,78,26
i.writeFile"c.png"

Outputs to the file c.png.

Pikchr, 52 51 48 bytes

up
box ht.25color-1fill gold
box same fill 22455

Output

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 112.32 76.32">
<path d="M2,74L110,74L110,38L2,38Z" style="fill:rgb(255,215,0);"></path>
<path d="M2,38L110,38L110,2L2,2Z" style="fill:rgb(0,87,183);"></path>
</svg>

Explanation

• up: The objects will be laid out from bottom to top.
• box: Draws a box (rectangle).
• ht .25: The box will be 0.25 inches tall. The default box width is 0.75 inches, which gives us the desired ratio of 3:1.
• color -1: The box will have no outline.
• fill gold: The box will be colored using the standard HTML color gold, which happens to be the color of the yellow stripe.
• box: Draws another box.
• same: The box will inherit all properties from the previous object.
• fill 22455: The number is 57B7 in hexadecimal, so the color of the box will be #0057B7.

Nibbles, 26.5 bytes (53 nibbles)

"P3 78 52 255 ".\`\~`D256^2028$ FFD7000057B7

Outputs a plain PPM file of 78x52 pixels, depicting the Ukrainian flag using exact colours.

"P3 78 52 255 "         # prepend the string "P3 78 52 255 " onto:
     `D256              # extract data in base 256,
  `\~                   # and divide into 2 chunks,
 \                      # reverse them,
.                       # and map over each
          ^2028$        # repeating it 2028 times. 
FFD7000057B7            # The data.

Go, 280 272 269 bytes

import(."image";c"image/color";d"image/draw";p"image/png";."os")
func f(){N,O,a,b:=NewUniform,d.Src,Rect,d.Draw
F:=NewRGBA(a(0,0,78,52))
b(F,a(0,0,78,26),N(c.RGBA{0,87,183,255}),Point{0,0},O)
b(F,a(0,26,78,52),N(c.RGBA{255,215,0,255}),Point{0,26},O)
p.Encode(Stdout,F)}

Attempt This Online!

Apparently Go has a (basic) image processing package in the standard library.

Prints the bytes of a 78-by-52px PNG to STDOUT.

Changelog

• -12 bytes by @The Thonnu

Explanation

import(."image";c"image/color";d"image/draw";p"image/png";."os")
func f(){                                     // boilerplate
B,Y,N,O:=c.RGBA{0,87,183,255},c.RGBA{255,215,0,255},NewUniform,d.Src
// define some useful variables
// - B and Y are RGBA colors
// - d.Src is how the image will be drawn on: Src replaces the pixels of the image with the source image.
F:=NewRGBA(Rect(0,0,78,52))                   // make a new empty RGBA image
d.Draw(F,Rect(0,0,78,26),N(B),Point{0,0},O)   // draw blue on the top half the image
d.Draw(F,Rect(0,26,78,52),N(Y),Point{0,26},O) // draw yellow on the bottom half of the image
p.Encode(Stdout,F)}                           // encode it as a PNG, and send it to STDOUT

C# (.NET), 178 chars

Effective code

var f=new Bitmap(78,52);for(int y=0;y<52;y++)for(int x=0;x<78;x++)if(y>25)f.SetPixel(x,y,Color.FromArgb(255,215,0));else f.SetPixel(x,y,Color.FromArgb(0,87,183));f.Save("f.bmp");

Readable version

using System.Drawing;
namespace UkrainianFlag
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //The effective code could replace the code in this method.

            var blue = Color.FromArgb(0, 87, 183);
            var yellow = Color.FromArgb(255, 215, 0);

            //Create the image holding the flag.
            var flag = new Bitmap(78, 52);

            //Iterate the pixels, row by row.
            for (int y = 0; y < flag.Height; y++)
            {
                for (int x = 0; x < flag.Width; x++)
                {
                    if (y >= flag.Height / 2)
                    {
                        flag.SetPixel(x, y, blue);
                    }
                    else
                    {
                        flag.SetPixel(x, y, yellow);
                    }
                }
            }

            //Store the flag image next to the exe-file.
            flag.Save("flag.bmp");
        }
    }
}

Output

Game Boy Color assembly, 99 97 bytes

Must be placed at $0150, to which it is jumped from $0100 (standard Game Boy stuff).

0E 40 3C E0 41 E6 02 E0 FF 76 F2 CB BF E2 3E 80
E0 68 21 69 FF AF 36 60 36 59 77 77 77 77 36 5F
36 03 3E 40 06 02 21 00 98 CD AB 01 3E 20 06 00
CD AB 01 AF 57 04 CD AB 01 04 CD AB 01 3E 10 42
26 80 CD AB 01 3E 20 06 FF CD AB 01 3E 30 70 23
72 23 BD 20 F9 F2 CB FF E2 18 FE 70 23 BD 20 FB
C9

Disassembly:

ROMCode:
    ld c, $40
; first we turn off the LCD so the LCD doesn't tell our mother[board] that it's their turn to access the VRAM

; wait for LCD Status to be at vblank to avoid hardware damage
; removing this "saves" eight bytes
; this is also our non-CGB/GBA/SGB2 filter: those will hang, because the way their A register is initialized, this will put them in an endless halt
.vblankWait:
    inc a ; on CGB and compatible, A is initialized to $11. in fact, that is how software is supposed to detect CGB compatibility.
    ldh [$ff41], a
    and $02
    ldh [$ffff], a
    db $76 ; halt. saves byte over "halt", which auto-inserts nop
           ; if you do this in a project, beware the halt bug.

; turn off the LCD
    ldh a, [c]
    res 7, a
    ldh [c], a

; now we fill the palette.

; the palette ram is indirectly accessed using a control register with an address and auto-increment bit and a data register
    ld a, $80
    ldh [$ff68], a
    ld hl, $ff69
    xor a

    ld [hl], $60
    ld [hl], $59
rept 4
    ld [hl], a
endr
    ld [hl], $5f
    ld [hl], $03

; now we fill the tile map.
    ld a, $40
    ld b, 2
    ld hl, $9800
    call FillWithB

    ld a, $20
    ld b, 0
    call FillWithB

    xor a
    ld d, a ; for later
    inc b
    call FillWithB

    inc b
    call FillWithB

; and now we have tile 0 be all color 0b00, tile 1 be all color 0b11, and tile 2 be all color 0b10
    ld a, $10
    ld b, d
    ld h, $80
    call FillWithB
    
    ld a, $20
    ld b, $ff
    call FillWithB

    ld a, $30
.fillTwoValues:
    ld [hl], b
    inc hl
    ld [hl], d
    inc hl
    cp l
    jr nz, .fillTwoValues

; turn on the LCD
    ldh a, [c]
    set 7, a
    ldh [c], a

; and now that we're done let's spin.
    jr @

FillWithB:
    ld [hl], b
    inc hl
    cp l
    jr nz, FillWithB
    ret

Game Boy Color colors are wonky. It's also 10:7, but that's close enough to 3:2.

Edit 1: Missed completing an optimization I had already partially done (ldh with [c]). -2 bytes.

Edit 2: More safe vblank wait code. No size change.

Edit 3: Edit 2 broke the second halt, which is now replaced with an infinite spin because fixing it requires more code. No size change, +1 embarrassment from not checking thoroughly enough.

Python (Thonny 4.0 REPL), 419 bytes

print("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAARMAAAC3CAMAAAAGjUrGAAAAD1BMVEUAW7v/1QAAVb+ln3n/2QAG3wIgAAAAzUlEQVR4nO3QsQGAMAzAsBT4/2b2eO0onaAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACASx62ednmY5vD5qSclJNyUk7KSTkpJ+WknJSTclJOykk5KSflpJyUk3JSTspJOSkn5aSclJNyUk7KSTkpJ+WknJSTclJOykk5KSflpJyUk3JSTspJOSkn5aSclJNyUk7KSTkpJ+WknJSTclJOykk5KSflpJyUk3JSTspJOSkn5aSclJNyUk7KSTkpJ+WknJSTclJOykk5KSflpH7zk2pa0LCuDAAAAABJRU5ErkJggg==")

Longer than a standard answer but ok. Thonny supports printing images if they’re in base64 form.

ARM Thumb machine code, Game Boy Advance, 36 bytes

04 20 00 06 05 49 01 80 48 06 09 0c 44 18 04 4a
13 0c 89 1e 42 52 63 52 fb d1 fe e7 03 04 00 96
40 59 5f 03

Thumb function that runs at a 4 byte aligned address.

Assembler source:

    .syntax unified
    .arch armv4t
    .globl ukraine
    .thumb
    .thumb_func
    // Runs at a 4 byte aligned address
    .p2align 2,0
ukraine:
    // 0x04000000 = REG_DISPCNT
    movs    r0, #0x04
    lsls    r0, r0, #24
    // Load packed halfword constants
    ldr     r1, consts
    // REG_DISPCNT = MODE_3 | BG2_ENABLE
    // Set to display mode 3, enable BG2 layer
    strh    r1, [r0]
    // r0 = 0x...0403 << 25 = 0x06000000 = VRAM address
    lsls    r0, r1, #25
    // Shift in loop counter/offset (0x9600)
    lsrs    r1, r1, #16
    // r4 = 0x06009600 = second half of screen
    adds    r4, r0, r1
    // Load packed colors
    ldr     r2, colors
    // Unpack
    lsrs    r3, r2, #16
    // Double memset16 loop
.Lloop:
    // Decrement counter, set flags
    subs    r1, r1, #2
    // Store blue
    strh    r2, [r0, r1]
    // Store yellow
    strh    r3, [r4, r1]
    // Loop while not 0
    bne     .Lloop
    // Idle spin
.Lspin:
    b       .Lspin

    .p2align 2,0
consts:
    // MODE_3 | BG2_ENABLE
    // Also used for vram address
    .hword  0x0403
    // Half of the screen in halfwords
    .hword  240 * (160 / 2) * 2

    // Converts r8, g8, b8 to RGB5
    .macro RGB8 r, g, b
        .hword  ((\r >> 3) << 0)  | ((\g >> 3) << 5) | ((\b >> 3) << 10)
    .endm

colors:
    RGB8    0, 87, 183   // blue
    RGB8    255, 215, 0  // yellow

This function switches the GBA to display mode 3, where VRAM is treated as a flat bitmap of 16-bit RGB5 pixels. This is the easiest to manipulate as there is no need for tilemaps or palettes, I can just fill VRAM with colors.

C (MSVC) + Win32, 106 bytes

r[4];p(c){FillRect(GetDC(0),r,CreateSolidBrush(c));}main(){*r=600;r[1]=200;p(12344064);r[3]=400;p(55039);}

Draws the flag onto the top window:

FLTK, 153 characters

Function{}{}{Fl_Window{}{xywh{9 9 78 52}}{Fl_Box{}{xywh{0 0 78 26}box FLAT_BOX color 0x0057b7ff}Fl_Box{}{xywh{0 26 78 52}box FLAT_BOX color 0xffd700ff}}}

Ungolfed:

Function {} {} {
    Fl_Window {} {
        xywh {9 9 78 52}
    } {
        Fl_Box {} {
            xywh {0 0 78 26}
            box FLAT_BOX
            color 0x0057b7ff
        }
        Fl_Box {} {
            xywh {0 26 78 52}
            box FLAT_BOX
            color 0xffd700ff
        }
    }
}

Sample output:

Lua + LÖVE, 154 characters

l=love
g=l.graphics
c=255
l.window.setMode(78,52)function l.draw()g.setBackgroundColor(0,87/c,183/c)g.setColor(1,215/c,0)g.rectangle("fill",0,26,78,52)end

Sample output:

Ruby with Shoes, 96 characters

Shoes.app(width:78,height:52){background rgb 0,87,183
stroke fill rgb 255,215,0
rect 0,26,78,52}

Sample output:

Ruby + paint, 73 bytes

You do need the paint gem installed, from rubygems: gem install paint

Update:

Thanks to manatwork for the much shorter:

require'paint';['#0057b7','#ffd700'].map{|c|5.times{puts Paint[?█*37,c]}}

Original attempt (127 bytes):

require'paint';c=['#0057b7','#ffd700'];(0..1).each do |i|;(0..4).each do;(0..36).each do;print Paint['█',c[i]];end;puts;end;end

WP2, 32 bytes

VWtsR1JpSUFBQUJYUlVKUVZsQTRUQlVBQUFBdlRjQU1BQkNRSkVQYjNUUmgvbWUzLzVuVUgvVUEK

WP2 (WebP2) is an image format based on AVIF. It's state-of-the-art in the field of DCT-based image formats, as far as I'm aware. It's also really good at lossless compression.

Encoded in Base64 RFC4648

Asymptote 88 82 bytes

(I update my shortest code here, including its history. Hope that it is legal!)

Run on http://asymptote.ualberta.ca/

// Asymptote 82 bytes
fill(box((0,0),(78,26)),rgb(0,87,183));fill(box((0,0),(78,-26)),rgb("#FFD700"));

// Asymptote 88 bytes
fill(box((0,0),(300,100)),rgb(0,87,183));
fill(box((0,0),(300,-100)),rgb(255,215,0));

In this world of civilization, it's hard to believe that there have been an invasion war from Russia. Stand with Ukraine!

Appendix TikZ 125 bytes (by @Joe85AC)

\documentclass[tikz]{standalone}\begin{document}\tikz{\def~#1;{\color[HTML]{#1}\fill rectangle(3,}~0057b7;);~ffd700;-1)}\stop

TikZ 187 bytes

\documentclass[tikz]{standalone}\begin{document}\tikz{\definecolor{b}{RGB}{0,87,183}\definecolor{r}{RGB}{255,215,0}\fill[b](0,0)rectangle(3,1);\fill[r](0,0)rectangle(3,-1);}\end{document}

TikZ 297 bytes

\documentclass[tikz,border=5mm]{standalone}
\begin{document}
\begin{tikzpicture}
\definecolor{Ukraine blue}{RGB}{0,87,183}
\definecolor{Ukraine yellow}{RGB}{255,215,0}
\fill[Ukraine blue] (0,0) rectangle (3,1);
\fill[Ukraine yellow] (0,0) rectangle (3,-1);
\end{tikzpicture}
\end{document}

JavaScript (Node.js), 94 bytes

Prints a solid flag (or not quite, depending on your font) in the specified rgb colors.

for(i=1;i<4108;i++)process.stdout.write(i%79?`\x1b[38;2;${i<2054?'0;87;183':'255;215;0'}m█`:`
`)

SVG, 132 bytes

<svg width="300"height="200"><rect width="300"height="100"fill="#0057b7"/><rect y="100"width="300"height="100"fill="#ffd700"/></svg>

C# (.NET Framework), 163 chars

Shorter version of Björn Larsson's answer.

void Draw(){var f=new Bitmap(78,52);for(int y=0;y<52;y++)for(int x=0;x<78;x++)f.SetPixel(x,y,Color.FromArgb(y>25?255:0,y>25?215:87,y>25?0:183));f.Save("f.bmp");}

Effective version with explanation:

using System.Drawing;

namespace Ukraine {
    internal class Program {
        static void Main() {
            // Create a bitmap.
            var f = new Bitmap(78, 52);

            // Iterate over the bitmap's pixels.
            for (int y = 0; y < 52; y++) {
                for (int x = 0; x < 78; x++) {
                    f.SetPixel(                  // Set the pixel...
                        x, y,                    // at the current x and y...
                        Color.FromArgb(
                            y > 25 ? 255 : 0,    // selecting the R value with a ternary expression...
                            y > 25 ? 215 : 87,   // selecting the G value with a ternary expression...
                            y > 25 ? 0 : 183)    // and selecting the B value with a ternary expression.
                        );
                }
            }

            // Save the bitmap.
            f.Save("f.bmp");
        }
    }
}

Produces an image in the exe's folder:

PostScript, 55 43 bytes

00000000: 3188 0238 5b2e 3030 3288 0030 202d 2e30  1..8[.002..0 -.0
00000010: 3036 8800 325d 2800 57b7 ffd7 2992 a333  06..2](.W...)..3
00000020: 2063 6f6c 6f72 696d 6167 65               colorimage

Tokenized version of:

1 2 8[.002 0 0 -.006 0 2]<0057b7ffd7>stopped 3 colorimage

The original solution without binary tokens was a bit shorter at 55 bytes:

1 2 8[.002 0 0 -.006 0 2]<0057b7ffd7>false 3 colorimage

These all use a stretched a 1x2 bitmap. To view, run through Ghostscript.

Processing, 92 Bytes

void setup(){size(78,52);background(#0057B7);}void draw(){fill(#FFD700);rect(0,26,78,26);}

Output

dc, 73 71 68 bytes

0d34[27P91PnA9P]dsax[33lax]sc[APd-r1+r]sn[35Pr1+d77<nrdD=cd26>u]dsux

Output:

Outputs a 78x26 grid of coloured '#' characters to stdout. This is a 3:2 aspect ratio assuming that the font's aspect ratio is 1:2.

Edits:

-2 bytes: use integers rather than strings for the newline and # character

-3 bytes: it turns out that dc will treat 'A' as 10 and 'D' as 13, even with the input radix set to 10. It also treats 'A9' as 109 (i.e. 'm') for some reason (looks like it treats each digit separately?)

Python + Pygame (122 bytes)

import pygame.display as p
s=p.set_mode((78,52))
s.fill((0,87,183),(0,0,78,26))
s.fill((255,215,0),(0,26,78,26))
p.flip()

Briefly flashes the flag on the screen before exiting.

BBC BASIC, 72 bytes

V. 19,0,16,255,215|25,97,78;26;25,4,78;27;19,0,16,0,87,183;25,97,-78;26;

Output

Windows PowerShell / PowerShell Core, 50 bytes

Only works in a PowerShell host.

,'blue'*9+,'yellow'*9|%{Write-Host('█'*78)-f $_}

Output (bit outdated because code was edited):

I also reposted this code in my GitHub Gist.

Try it online not available, because it cannot render colors (so none of the flag is shown for tio.run).

Perl 5, 36 bytes

$#a=78;print".[${_}m@a
"x13for 44,43

Try it online!

Outputs using ANSI escape sequences.

WebP, 42 bytes

UklGRiIAAABXRUJQVlA4TBUAAAAvTcAMABCQJEPb3TRh/me3/5nUH/UA

Encoded in Base64 RFC4648

Applesoft Basic, 88 bytes

1Y=0
2M=13
3GR
4COLOR=2
5HLIN0,38ATY
6Y=Y+1
7IFY<M GOTO5
8COLOR=13
9M=26
10Y=13
11GOTO5

Kind of cheating because it only is 39:26. I don't know if this is actually valid but it works here. A high res but worse color answer for 93 bytes:

1Y=0
2M=26
3HGR
4HCOLOR=6
5HPLOT0,Y TO78,Y
6Y=Y+1
7IFY<M GOTO5
8HCOLOR=5
9M=52
10Y=26
11GOTO5

C++, GCC 227216 chars

Hardly golf considering the language/tools, but still worth a try

#import<boost/gil/extension/io/pnm.hpp>
int n;int main(){boost::gil::rgb8_image_t i{999,666};for_each_pixel(view(i),[](auto&p){n++/999<333?p={0,87,183}:p={255,215,0};});write_view("U",view(i),boost::gil::pnm_tag{});}

It's not even obfuscated if reformatted:

#import <boost/gil/extension/io/pnm.hpp>
int n;
int main() {
    boost::gil::rgb8_image_t i{999, 666};
    for_each_pixel(view(i), [](auto& p) {
        n++ / 999 < 333 ? p = {0, 87, 183} : p = {255, 215, 0};
    });
    write_view("U", view(i), boost::gil::pnm_tag{});
}

The U file is in PNM format, meaning no link dependencies. Built with GCC-10 results in 19K binary.

Live On Compiler Explorer

Resulting file:

U: Netpbm image data, size = 999 x 666, rawbits, pixmap

Ly, 39 bytes

99*:3*&s*:[r009r,]+[r990r,]+'Po9lf2*f3r

Try it online!

This code pushes RGB values compatible with PPM ASCII formatted image into the stack, then creates a minimum PPM header before exiting. The numbers on the stack are printed automatically when the code exits.

Generate width/height numbers, figure out "half the pixels" count

 99*         - Push "81" on stack (will be 1/2 height, 1/3 width)
    :        - Duplicate top of stack
     3*      - Multiple by 3 (yields width)
       &s    - Save stack to backup (needed later for header)
         *   - Multiple to get "half the pixels"
          :  - Duplicate top of stack

Generate blue pixels, pushed onto the stack

 [      ]+  - Loops one per pixel
  r         - Reverse stack
   009      - Push "0 0 9" onto stack
      r     - Reverse to get pixel count back to top
       ,    - Decrement counter

Generate yellow pixels, pushed onto the stack

 [      ]+  - Loops once per pixel
  r         - Reverse stack
   990      - Push "9 9 0" onto stack
      r     - Reverse to get pixel count back to top
       ,    - Decrement counter

Print PPM header

 'Po          - Print "P"
    9         - Push 9 as "max RGB value"
     l        - Load "width and height" from backup cell
      f       - Flip top two entries (width, height)
       2*     - Double to get the height
         f    - Flip top two entries back
          3   - Push 3, the "PPM image type"
           r  - Reverse stack, stack prints automatically

Python 3, 330 273 bytes

The following piece of code shows the Ukrainian flag in coloured text when executed in the Windows Command Prompt

import sys
from termcolor import *
import os
os.system("")
t=colored("#","blue",attrs=["reverse","blink"])
for x in range(26):
    for x in range(78):
        print(end=t)
    print()
t=colored("#","yellow",attrs=["reverse","blink"])
for x in range(26):
    for x in range(78):
        print(end=t)
    print()

Try It Online is not available, for the reason it wouldn't display the colours.

Commodore 64 machine code, 36 33 31 bytes

Code

.C:c000  78          SEI
.C:c001  A9 80       LDA #$80
.C:c003  A0 97       LDY #$97
.C:c005  8D 11 D0    STA $D011
.C:c008  2C 11 D0    BIT $D011
.C:c00b  F0 FB       BEQ $C008
.C:c00d  2C 11 D0    BIT $D011
.C:c010  D0 FB       BNE $C00D
.C:c012  8C 20 D0    STY $D020
.C:c015  CC 12 D0    CPY $D012
.C:c018  D0 FB       BNE $C015
.C:c01a  CE 20 D0    DEC $D020
.C:c01d  D0 E9       BNE $C008
.c01f  
(C:$c01f) g c000

Output

Edit 1: Found a way to reuse the stx$d020 without introducing flickering. Geometry change: +1 raster scan line of blue, -1 of yellow. Tweaked saturation and brightness settings on the virtual CRT to obtain nicer colors.

Edit 2: Got rid of one register and saved two bytes.

Edit 3: Edit 2 reintroduced the overscan flicker, argh! This is fixed now. Geometry change: another extra line of blue at the expense of a line of yellow. Ditched the virtual CRT tweak, this is the output with the external palette called "VICE".

D Language, 122 bytes

Code

import std.stdio;
void main(){
char[78]l='.';
foreach(c;["\033[44m","\033[43m"])foreach(x;0..13)writeln(c,l,"\033[0m");
}

Output

PHP Imagick (209 chars)

Draw and output the image to the browser (Imagick is a native PHP extension).
No line break are needed for execution :

header('Content-Type:image/png');
$d=new\ImagickDraw();
$d->setFillColor('#0057B7');
$d->rectangle(0,0,990,330);
$i=new\Imagick();
$i->newImage(990,660,'#FFD700');
$i->setImageFormat('png');
$i->drawImage($d);
echo$i;

HTML, 73 bytes

<p style=aspect-ratio:3/2;background:linear-gradient(#0057B7+50%,gold+50%

Thanks to @pxeger for pointing out that you can remove the quotes and not close the tag.

Haskell, 83 81 69 bytes

My first haskell submission.

This code defines a function that prints the flag to stdout using ansi escape codes.

n?s=[1..n]>>s
putStr$"43">>= \c->13?(78?("\27[4"++c:"m \27[m")++"\n")

Dyalog APL,55 byte

(⊂'P3 78 52 255 ',⍕,⍉2028/(3⍴256)⊤22455 16766720)∘⎕NPUT

Write a plain text PPM image to provided filename.

$ cat out.ppm
P3 78 52 255 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87
183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87
...
183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87 183 0 87
183 0 87 183 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0
255 215 0 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0
255 215 0 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0 255 215 0
...

Red, 59 57 54 53 51 50 bytes

x: 99x33 view/tight[below h1 x#0057B7 h1 x#FFD700]

-1 byte thanks to an anonymous user!

-2 more bytes saved by an anonymous user!

-1 again

Node JavaScript 84, 83, 77, 66

83 bytes

f=n=>`\x1b[48;5;${n}m${' '.repeat(78)}\x1b[m
`.repeat(13);console.log(f(33)+f(220))

draws the flag on terminal output, 1 byte saved thanks to @Samathingajig's suggestion to use an inline LF instead of '\n'.

You can try copying and pasting the code after the REPL prompt (brought up by running node in a terminal). Alternatively save the code to file and run it with node filename.

77 bytes

Another 6 bytes saved by replacing each occurence of \x1b (4bytes) with a single ASCII ESC character (1 byte). Due to character set limitations in HTML, you can run the code snippet to see the actual code and length. Save it to file and run with Node to see the flag:

js.value="f=n=>`\x1b[48;5;${n}m${' '.repeat(78)}\x1b[m\n`.repeat(13);console.log(f(33)+f(220))"
console.log("Length=%s", js.value.length);

<textarea id="js" style="width:90%"></textarea>

<!-- Click on Run Code Snippet to see the code-->

• Run the 77 byte version as a file:

  Raw ANSI color escapes in pasted source appear to be filtered out (sanitized?) before node's REPL prompt echoes or evaluates code, resulting in no flag being drawn.

• Ansi 8-bit color codes were used because 24 bit codes were not effective in terminals tested.

• Tested in linux terminal and Windows CMD.exe terminal. GitHub's bash terminal for windows used Cyan and Yellow instead of the colors specified.

• The 3:2 aspect ratio is approximate and may vary according to the font metrics of the terminal font.

flag.js (66 bytes)

f=h=>`${h[0].repeat(78)}
`.repeat(26)
console.log(f`💙`+f`💛`)

• Run from file in node and redirect stdout to a text file

    node flag > flag.txt
  

• Load the text file in a browser with dark mode selected (preferably).

To preview run the following code snippet (it has an additional line to provide a "console.log" functions to mimic writing to stdout), full screen the snippet window and reduce page zoom as required to make the flag fit within the window.

console.log = s=> document.querySelector('code').textContent+=s;

f=h=>`${h[0].repeat(78)}
`.repeat(26)
console.log(f`💙`+f`💛`)

pre, code{height: 100%; width: 100%; background:black}

<pre><code></code></pre>

Batch, 93 bytes

@for %%i in (44 103)do @for /l %%j in (1,1,12)do @set/p=␛[%%im%PATH:~,80%<nul
@set/p=␛[m<nul

Assumes a default 80×25 screen with a PATH variable of at least 80 characters (this is true on a default Windows 10 installation). The last line is to stop the prompt appearing in yellow which wouldn't be a line of at least 78 non-whitespace characters and would therefore be illegal.

Note that ␛ is used to represent the nonprintable `` (good luck copying and pasting that).

Unicorn, 14 10 bytes

P3X4Y3C7P3

Note: There isn't a closer blue; the alternative is cyan.

PaperScript, 80 bytes

R=Path.Rectangle
R(1,1,99,33).fillColor="#0057b7"
R(1,34,99,33).fillColor="gold"

Try it here!

TI-Basic 83, 25 bytes

This is a rather extreme abuse of the "closest color in your language" rule, as the TI-83 Plus' LCD screen is only capable of two colors (black and "white"; white in air-quotes, as the off color is more green than anything), but it beats all the other graphical output answers except Unicorn, and I imagine a newer TI calculator with a color display, such as the TI-84 Plus CE, could do it right with almost identical code, but I don't think I can test that, as I don't own any such calculator, and a quick search of the internet didn't find any free emulators.

:AxesOff
:Shade(0,10
:Shade(-10,0,-10,10,3,2

Edit: @MarcMush pointed out that, per site consensus, I can assume that the graph bounds are already initialized to ZStandard, allowing me to trim that, and explained some details of how the calculator's MEM screen displays program bytecounts, revising my bytecount down to 25

Output:

To make my rules abuse slightly better, I did opt to make the "yellow" half be lightly filled instead of empty. Although this might not technically constitute a solid color, in the context of what a TI-83 can display, I feel like it is closer to yellow than no fill.

Bash (+ Image Magick) 69 67 64 characters

The following command will output the required file on standard output (as a PNM picture) if Image Magick is installed. Since I had some issues with binary value 0 in both RGB color codes, I replaced it with 1 instead:

convert - -scale 78x52\! -<<<$'P6 1 2 255 \x01W\xb7\xff\xd7\x01'

SimpleTemplate 0.84, 102 bytes

This answer outputs a flag with 78x52 characters.

{@fori to51}{@forto77}<b{@ifi is lowerthan26} x{@/}>@{@/}<br>{@/}<style>b{color:#0057B7}[x]{color:gold

This code generates 20474 bytes of pure HTML nightmare, but works!

Ungolfed

The golfed code is pretty hard to read, so, here's an ungolfed version.

{@for i from 0 to 51}
    {@for j from 0 to 77}
        {@echo "<b"}
        {@if i is lower than 26}
            {@echo " x"}
        {@/}
        {@echo ">@"}
    {@/}
    {@echo "<br>"}
{@/}
{@echo "<style>b{color:#0057B7}[x]{color:gold"}

This code behaves exactly the same as the golfed version.

Output

This is a nightmare, but, it outputs the following (lightly edited to work as a StackSnippet):

b{color:#0057B7}[x]{color:gold

<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<b x>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br><b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<b>@<br>

You can try the code here: https://www.ideone.com/xIjh40

JavaScript/HTML 117 112 102 100 98 bytes

c=c.getContext`2d`
f=k=>c.fillRect(0,(c.fillStyle=k)>c?33:0,99,33)
f`gold`,f`#0057b7`

<canvas id=c>

With continued help from @Samathingamajig and @pxeger's answer

1. <canvas id=c> is invalid HTML when missing an end tag but at least Chromium-Edge and Firefox create the element anyway.

2. c=c.getContext`2d` is using template literal syntax,

Slava Ukraini!

C (gcc), 126 115 109 bytes

• -6 thanks to ceilingcat
• -6 thanks to AZTECCO
• -3 by using gold which seems to work instead of #FFD700

Produces an XPM image. If there's another indexed colour format that is smaller to produce from C, I'd be very interested!

i;a(c){for(i=2730;i--;putchar(i%91?c:10));}f(){puts("! XPM2\n90 60 2 1\na c #0057B7\nb c gold");a(97);a(98);}

Try it online!

HTML + SVG + CSS, 73 70 68 66 bytes

<svg width=225 style=background:linear-gradient(#0057B7+50%,gold+0

Explanation:

• As a replaced element, the <svg> element in HTML defaults to dimensions of 300px x 150px
• Setting width="225" gives the <svg> a width/height ratio of 225px / 150px or 3 / 2

Update 1: Another 3 bytes sliced off after @pxeger's suggestions on how to abuse the HTML even further.

Update 2: A further 2 bytes shaved off thanks to @cornonthecob's ideas on how to strip from the HTML any vestige of its remaining self-respect.

Update 3: 2 more bytes removed thanks to @Sphinxxx's excellent observation that gold may be followed by the value 0 (or anything less than 50%) without visibly altering the linear-gradient background.

HTML4, 98 95 85 bytes

<table width=78 height=52 cellspacing=0><tr><td bgcolor=#0057B7><tr><td bgcolor=gold>

Edit: Saved 3 bytes by using @pxeger's observation that gold is #FFD700. Saved 10 bytes thanks to @IsmaelMiguel. Note that the sizes here work in Firefox but other browsers may have other default table styles which alter the resulting size.

SQL, 379 346 244 bytes

This uses Microsoft T-SQL in SQL Management Studio's (SSMS) to generate spatial data. This code should work with Oracle's PL-SQL with few changes. Not sure about how it would work with others.

Updated with changes to reduce byte count by t-clausen.dk and removed unnecessary spaces and line breaks, though it's not very readable anymore.

DECLARE @C INT=1,@ VARCHAR(MAX)='' WHILE @C<32 SELECT @+='|.0,0 .x'+iif(@C=14,'|26,0 x',''), @C+=1 SET @=REPLACE(REPLACE(REPLACE(@+'|-26,0 -26?', '|','SELECT CAST(''POLYGON((0 0,78 0,78 '),'x','26?UNION ALL '),'?',',0 0))''AS GEOMETRY)')EXEC(@)

Update using REPLACE to cut out redundant parts of the strings and removing some extra spaces after commas:

DECLARE @C INT = 1,@S VARCHAR(MAX) = '',@G VARCHAR(99)='|1 0,1 .1,0 .1,0 0))'' AS GEOMETRY) G UNION ALL ' 

WHILE @C<=31 --loop is just to cycle through the colors 

BEGIN
    SET @S+=@G  --MERGE SELECT STATEMENTS OF UNVIEWABLE OBJECTS (TOO SMALL) FOR WRONG COLORS 
    IF @C=14 SET @S+='|78 0,78 26,0 26,0 0))'' AS GEOMETRY) UNION ALL '  --ADD TOP OF FLAG IN BLUE
    SET @C+=1   --UPDATE COLOR COUNTER
END
SET @S+='|78 0,78 -26,0 -26,0 0))'' AS GEOMETRY)'
SELECT @S = REPLACE(@S,'|','SELECT CAST(''POLYGON ((0 0,')
EXEC (@S)  --execute query

Original T_SQL:

DECLARE @C INT = 1,@S VARCHAR(MAX) = '',@G VARCHAR(99)='SELECT CAST(''POLYGON ((0 0, 1 0, 1 .1, 0 .1, 0 0))'' AS GEOMETRY) G UNION ALL ' 

WHILE @C<=31 --loop is just to cycle through the colors 

BEGIN
    SET @S+=@G  --MERGE SELECT STATEMENTS OF UNVIEWABLE OBJECTS (TOO SMALL) FOR WRONG COLORS 
    IF @C=14 SET @S+='SELECT CAST(''POLYGON ((0 0, 78 0, 78 26, 0 26, 0 0))'' AS GEOMETRY) UNION ALL '  --ADD TOP OF FLAG IN BLUE
    SET @C+=1   --UPDATE COLOR COUNTER
END

SET @S+='SELECT CAST(''POLYGON ((0 0, 78 0, 78 -26, 0 -26, 0 0))'' AS GEOMETRY)' --ADD BOTTOM OF FLAG IN YELLOW(ish)

EXEC (@S)  --execute query

Unfortunately, the colors look a little faded. Apologies to Ukraine for the bad colors. There don't seem to be too many colors available and they are all faded tones.

SQL Fiddle doesn't handle the spatial data. If there's another fiddle site that does, let me know or add a link. Or if there's a way to set the colors.

Rust, 107 106 92 86 85 bytes

NOTE: you can't actually copy the escape characters from the code below for some reason. Be sure to click the try it online link if you want to test the code; don't copy it from the answer! The odd thing is, the escape characters could be copied in the edit preview, but not in the actual answer. I've asked a question on Meta about it.

fn main(){print!("[38;2;0;87;183m{}[38;5;220m{0}",("X".repeat(78)+"
").repeat(13))}

If you want one more byte, you can use █ instead of X.

Try it online!

To 106 bytes: Removed the first r, and added a 0 in the second pair of braces {}.

To 92 bytes: Thanks to Toothbrush's help, I was able to reduce the code even more by removing the let statement, rearranging the formatting, and changing the gold color to 220.

To 86 bytes: Credit to Aiden4, I reduced the code to 86 bytes by using literal escape characters. I know you can't see them in the code, but you can see them online (86-byte version).

To 85 bytes: Removed the \n and just used an actual newline in the code.

Zsh -F, 38 bytes

eval ';<<<␛[4'{4,3}m\${(l:78+{a..m}:)}

Attempt This Online!

␛ should be the literal ASCII escape character, but this doesn't display in StackExchange markdown.

Demo

MSWLogo, I'm assuming 173 167 bytes.

to f :a :b :c :y
setpos(list 0 :y)
setpc(list :a :b :c)
repeat 2[fd 26 rt 90 fd 72 rt 90]
setpos(list 1 :y+1)
setfc(list :a :b :c)
fill
end
f 225 215 0 0 f 0 87 153 26

C (GCC), 78 bytes

main(i){puts("P6\n78 52\n255");for(;i<4057;)printf(i++<2029?"%cW\xb7":"\xff\xd7%c",0);}

Attempt This Online! (code in Base64)

Outputs a PPM image to STDOUT.

HTML+SVG, 39 bytes

<svg viewbox=12.5,-8.9,1.5,1><text>😴

The question forbids zooming in on the Ukraine flag... but not the flag of Sweden! Apparently that's disallowed too, so I'm using an emoji.

This code is terrible practice and probably doesn't work on most browsers/OSes. It works on Firefox 98 on MacOS 12.2.1, and the emoji itself is very system dependent in its size and layout.

In particular, it doesn't seem to work in a Stack Snippet, so here's something: Try it Online!

Run this at your own risk, it will severely lag your computer.

CSS, 78 75 74 71 bytes

*>*{width:9em;border-top:3em solid #0057B7;border-bottom:3em solid gold

Edit: Saved 3 bytes by using @pxeger's observation that gold is #FFD700. Saved 1 byte thanks to @RickN. Saved 3 bytes thanks to @IsmaelMiguel.

JavaScript (browser console), 94 bytes

j='height:4em;width:12em;display:block;background:',console.log('%c %c ',j+`#0057B7`,j+`gold`)

96 bytes

console.log('%c %c ',`${j='height:4em;width:12em;display:block;background:'}#0057B7`,`${j}gold`)

This is shorter (85 bytes), but in a bit of a grey area? If you size the console perfectly, the output will be the correct dimensions:

console.log('%c %c ',`${j='display:block;height:6em;background:'}#0057B7`,`${j}gold`)

97 characters

console.log('%c %c ',`${j='height:26px;width:78px;display:block;background:'}#0057B7`,`${j}gold`)

I think this works in most browsers these days?

(Incidentally, I note that the image in the question is not actually the colours described.)

Perl (51 characters)

The following piece of code writes the file as a PNM picture

say"P6 78 52 255 ","\0W\xb7"x2028,"\xff\xd7\0"x2028

Python 3 + Pillow, 120 100 bytes

from PIL.Image import*;i=new("RGB",(78,52));i.putdata([(0,87,183)]*2028+[(255,215,0)]*2028);i.show()

Wolfram Language (Mathematica), 56 55 bytes

Image@{{{0,29,61}/85},{{1,.843,0}}}~ImageResize~{78,52}

Try it online!

• The best I've found using exponentiation, 56 byte:

Image@{{{0,.05,.4}},{{1,.62,0}}}^.36~ImageResize~{78,52}
Image@{{{0,.19,.6}},{{1,.77,0}}}^.65~ImageResize~{78,52}
Image@{{{0,.26,.66}},{{1,.81,0}}}^.8~ImageResize~{78,52}

• The only valid dimension that can be written in fewer bytes than {78,52} is 9{9,6}.
  If it weren't for x~f~y precedence over xy, this would have saved one byte.

Java, 169 bytes

import java.awt.*;v->new Frame(){public void paint(Graphics g){for(int i=0;i<2;g.fillRect(0,i*30-i/2*4,78,26))g.setColor(new Color(i*255,i*128+87,++i%2*183));}{show();}}

Output:

Explanation:

import java.awt.*;        // Required import for Frame/Graphics/Color
v->                       // Method with empty unused parameter and Frame return
  new Frame(){            //  Create a Frame (window for graphical output)
    public void paint(Graphics g){
                          //   Overwrite its default paint method:
      for(int i=0;i<2     //    Loop `i` in the range [0,2):
          ;               //      After every iteration:
           g.fillRect(    //       Draw the rectangle
             0,i*30-i/2*4,//       at x,y position 0,30i-i//2*4 (i=1→30; i=2→56),
                          //       where the +30 is to account for the title-bar
             78,26))      //       of 78 pixels wide and 26 pixels high
                          //       (so the flag is the minimum required 78x52)
       g.setColor(new Color(i*255,i*128+87,++i%2*183));}
                          //     Change the RGB-color based on `i`:
                          //      i=0 (blue):     0, 87,183
                          //      i=1 (yellow): 255,215,  0
                          //     (and increase `i` by 1 with `++i`)
  {                       //   And in an inner initializer block:
   show();}}              //    Show the frame

PostScript, 191 bytes

Prints the flag starting at 1"x1"; 3"x2" in size. This is my first try at a PostScript submission, so it's probably not the smallest possible.

%!
/i{72 mul}def/c{255 div}def/b{newpath moveto 3 i 0 i rlineto 0 i 1 i rlineto -3 i 0 i rlineto closepath fill}def 0 87 c 183 c setrgbcolor 0 i 1 i b 1 215 c 0 setrgbcolor 0 i 0 i b showpage

Python 3 + tkinter, 132 128 124 bytes

There are several Python 3 answers already here, but none of them use tkinter, so I thought I'd add one that uses tkinter.Canvas:

from tkinter import*
c=Canvas(Tk())
c.pack()
d=c.create_rectangle
d(5,5,83,31,f="#0057B7")
d(5,31,83,57,f="gold")
mainloop()

To 128 bytes: Thanks to the help of pxeger, using a wildcard import reduces the size by 4 bytes.

To 124 bytes: Thanks to the help of des54321, removing the space before the * and changing the #FFD700 to gold reduced the code by another 4 bytes.

Outputs a mostly empty screen with the flag in the corner:

Python 3, 53 51 45 42¹ bytes

(+2 bytes if you want to use the Full Block Unicode Character █ instead of X)

¹ saved 3 bytes thanks to @pxeger

x="\x1b[3%dm"+("\n"+"X"*78)*13;print(x%4,x%3)

Attempt This Online!

Nicer alternative that uses background colors instead of foreground colors:

x="\x1b[4%dm"+("\n"+" "*78)*13;print(x%4+x%3)

Note that this solution is not valid since it uses spaces.

Attempt This Online!

Here, the programs are represented with 3 more bytes, since the byte \x1b does not get rendered (see ATOs).

On my terminal 13 rows seems to be the appropriate height, but it may vary.

ZSH, 93 characters

This works in ZSH. I'm using Ubuntu, but ZSH on other systems should work fine. I have no hidden Unicode characters

a(){printf "`printf '.%.0s' {1..78}w`\n%.0s" {1..13}};printf '\033[44m';a;printf '\033[43m';a

Output

Note: for some reason, if you run it many times, it breaks, so I advise running reset between invocations of this.

Explanation

# make a function named a
a() {
  # generate a row of periods followed by a newline, and print that row 13 times. See https://stackoverflow.com/a/5349842/16886597 for exactly what that does. Basically, this function creates a 78x13 grid of dots, and prints them to the screen
  printf "`printf '.%.0s' {1..78}w`\n%.0s" {1..13}
};
# set the color to blue
printf '\033[44m';
# print the dots
a;
# set the color to yellow
printf '\033[43m';
# print the dots
a

Note that I also use the shortcut for command substitution, saving one char.

R, 72 58 55 bytes

barplot(rbind(1,1),3,co=c("gold","#0557b7"),bo=NA,as=1)

Try it on rdrr.io!

Python 3 + pygame, 124 117 bytes

There's already two other python solutions to this problem, but I might as well add a third.

from pygame import*
d,r=display,draw.rect
s=d.set_mode()
r(s,"#0557b7",(0,0,78,26))
r(s,"gold",(0,26,78,26))
d.flip()

There might be something I could golf by being smarter with sizes, but this seems pretty close to optimal. By pure luck, "gold" happens to be exactly equal to #ffd700 in pygame's color library, scraping off 3 bytes.

Edit -7 bytes: Hold on a sec apparently you don't actually need to do pygame.init()??? I strongly suspect this is undefined behavior, but it works even running from the command line, so who am I to argue.

Output:

Desmos, 56 54 bytes

C=rgb([0,255],[87,215],[183,0])
[2,0]<y<[4,2]\{0<x<6\}

Try It On Desmos!

Try It On Desmos! - Prettified

I noticed that when I converted the rgb values to hsv, I got that both had a common s value of 100.0. It saves one byte compared to rgb, but I wasn't sure if the values I got were exact or if they were just rounded (especially the v value of 71.8 for the blue color), so I decided not to use hsv in case it was inaccurate.

Racket, 94 bytes

(require 2htdp/image)(define(f c)(rectangle 78 26"solid"c))(above(f(color 0 87 183))(f"gold"))

HTML + CSS, 79 bytes

<p style=background:#0057B7><p><style>*{aspect-ratio:3;margin:0;background:gold}

The final } should be removed, but this doesn't work in a Stack Snippet.

The HTML named colour gold is exactly the right colour for the yellow of the flag. I wonder whether this is a coincidence.

QBasic, 56 bytes

SCREEN 9
LINE(1,1)-(99,33),1,BF
LINE(1,34)-(99,66),14,BF

Try it at Archive.org.

Draws a 99x66 flag on the screen:

Coding, 84 bytes

>p
(width:78px;border-top:26px solid #FFD700;border-bottom:26px solid #0057B7)@style

borrowing from the CSS answer.