import sys

def write_int(value, size):
    return value.to_bytes(size, byteorder='little')

def create_gif():
    # GIF Header
    gif = b'GIF89a'
    
    # Logical Screen Descriptor
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x80'  # Global Color Table Flag
    gif += b'\x00'  # Background Color Index
    gif += b'\x00'  # Pixel Aspect Ratio
    
    # Global Color Table
    gif += b'\xFF\xFF\xFF'  # White (Background)
    gif += b'\xFF\x00\x00'  # Red (Triangle)
    gif += b'\x00\x00\x00'  # Black (Unused)
    gif += b'\x00' * 253 * 3  # Remaining colors (unused)
    
    # Image Descriptor
    gif += b'\x2C\x00\x00\x00\x00'  # Image Separator and Position
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x00'  # Local Color Table Flag
    
    # Image Data
    gif += b'\x07'  # LZW Minimum Code Size
    
    # Compressed image data
    image_data = []
    for y in range(200):
        row = []
        for x in range(200):
            if y > x and y + x < 200:
                row.append(1)  # Red for triangle
            else:
                row.append(0)  # White for background
        image_data.extend(row)
    
    # LZW compression (simplified)
    compressed = bytearray([0x80])  # Clear code
    current_code = 2
    buffer = 0
    bits = 0
    
    for pixel in image_data:
        buffer |= pixel << bits
        bits += 8
        while bits >= 9:
            compressed.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8
    
    if bits > 0:
        compressed.append(buffer & 0xFF)
    
    compressed.append(0x81)  # End of Information code
    
    # Write compressed data
    for i in range(0, len(compressed), 255):
        chunk = compressed[i:i+255]
        gif += bytes([len(chunk)]) + chunk
    
    gif += b'\x00'  # Block Terminator
    gif += b'\x3B'  # GIF Trailer
    
    return gif

if __name__ == "__main__":
    gif_data = create_gif()
    sys.stdout.buffer.write(gif_data)

python triangle_gif.py > /tmp/a.gif

import sys

def write_int(value, size):
    return value.to_bytes(size, byteorder='little')

def create_gif():
    # GIF Header
    gif = b'GIF89a'
    
    # Logical Screen Descriptor
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x80'  # Global Color Table Flag
    gif += b'\x00'  # Background Color Index
    gif += b'\x00'  # Pixel Aspect Ratio
    
    # Global Color Table
    gif += b'\xFF\xFF\xFF'  # White (Background)
    gif += b'\xFF\x00\x00'  # Red (Triangle)
    gif += b'\x00\x00\x00'  # Black (Unused)
    gif += b'\x00' * 253 * 3  # Remaining colors (unused)
    
    # Image Descriptor
    gif += b'\x2C\x00\x00\x00\x00'  # Image Separator and Position
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x00'  # Local Color Table Flag
    
    # Image Data
    gif += b'\x07'  # LZW Minimum Code Size
    
    # Compressed image data
    image_data = []
    for y in range(200):
        row = []
        for x in range(200):
            if y > x and y + x < 200:
                row.append(1)  # Red for triangle
            else:
                row.append(0)  # White for background
        image_data.extend(row)
    
    # LZW compression (simplified)
    compressed = bytearray([0x80])  # Clear code
    current_code = 2
    buffer = 0
    bits = 0
    
    for pixel in image_data:
        buffer |= pixel << bits
        bits += 8
        while bits >= 9:
            compressed.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8
    
    if bits > 0:
        compressed.append(buffer & 0xFF)
    
    compressed.append(0x81)  # End of Information code
    
    # Write compressed data
    for i in range(0, len(compressed), 255):
        chunk = compressed[i:i+255]
        gif += bytes([len(chunk)]) + chunk
    
    gif += b'\x00'  # Block Terminator
    gif += b'\x3B'  # GIF Trailer
    
    return gif

if __name__ == "__main__":
    gif_data = create_gif()
    sys.stdout.buffer.write(gif_data)

import sys

def write_int(value, size):
    return value.to_bytes(size, byteorder='little')

def create_gif():
    # GIF Header
    gif = b'GIF89a'
    
    # Logical Screen Descriptor
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x80'  # Global Color Table Flag
    gif += b'\x00'  # Background Color Index
    gif += b'\x00'  # Pixel Aspect Ratio
    
    # Global Color Table
    gif += b'\xFF\xFF\xFF'  # White (Background)
    gif += b'\xFF\x00\x00'  # Red (Triangle)
    gif += b'\x00\x00\x00'  # Black (Unused)
    gif += b'\x00' * 253 * 3  # Remaining colors (unused)
    
    # Image Descriptor
    gif += b'\x2C\x00\x00\x00\x00'  # Image Separator and Position
    gif += write_int(200, 2)  # Width
    gif += write_int(200, 2)  # Height
    gif += b'\x00'  # Local Color Table Flag
    
    # Image Data
    gif += b'\x07'  # LZW Minimum Code Size
    
    # Compressed image data
    image_data = []
    for y in range(200):
        row = []
        for x in range(200):
            if y > x and y + x < 200:
                row.append(1)  # Red for triangle
            else:
                row.append(0)  # White for background
        image_data.extend(row)
    
    # LZW compression (simplified)
    compressed = bytearray([0x80])  # Clear code
    current_code = 2
    buffer = 0
    bits = 0
    
    for pixel in image_data:
        buffer |= pixel << bits
        bits += 8
        while bits >= 9:
            compressed.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8
    
    if bits > 0:
        compressed.append(buffer & 0xFF)
    
    compressed.append(0x81)  # End of Information code
    
    # Write compressed data
    for i in range(0, len(compressed), 255):
        chunk = compressed[i:i+255]
        gif += bytes([len(chunk)]) + chunk
    
    gif += b'\x00'  # Block Terminator
    gif += b'\x3B'  # GIF Trailer
    
    return gif

if __name__ == "__main__":
    gif_data = create_gif()
    sys.stdout.buffer.write(gif_data)

import sys

# GIF header and logical screen descriptor
gif_header = b'GIF89a'
width, height = 200, 200
packed_fields = 0b10010001  # Color table: yes, 2 colors, 1 bit per pixel
color_resolution = 1
background_color = 0
pixel_aspect_ratio = 0

# Global color table
white = [255, 255, 255]
red = [255, 0, 0]

# Image data
image_data = bytearray([0] * (width * height // 8))

# Draw triangle
for y in range(height):
    for x in range(width):
        if (y >= 100 and x >= 100 - (y - 100) and x <= 100 + (y - 100)):
            byte_index = (y * width + x) // 8
            bit_index = 7 - ((y * width + x) % 8)
            image_data[byte_index] |= (1 << bit_index)

# LZW compress image data
def lzw_compress(data):
    dict_size = 4
    dictionary = {(i,): i for i in range(dict_size)}
    result = []
    w = ()
    for pixel in data:
        wc = w + (pixel,)
        if wc in dictionary:
            w = wc
        else:
            result.append(dictionary[w])
            dictionary[wc] = dict_size
            dict_size += 1
            w = (pixel,)
    if w:
        result.append(dictionary[w])
    return result

compressed = lzw_compress([b for byte in image_data for b in f'{byte:08b}'])

# Convert compressed data to bytes
min_code_size = 2
compressed_bytes = bytearray()
current_byte = 0
bit_count = 0

for code in compressed:
    current_byte |= (code << bit_count)
    bit_count += min_code_size + 1
    while bit_count >= 8:
        compressed_bytes.append(current_byte & 0xFF)
        current_byte >>= 8
        bit_count -= 8

if bit_count > 0:
    compressed_bytes.append(current_byte)

# Write GIF to stdout
sys.stdout.buffer.write(gif_header)
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([packed_fields, background_color, pixel_aspect_ratio]))

# Global Color Table
for color in [white, red]:
    sys.stdout.buffer.write(bytes(color))

# Image Descriptor
sys.stdout.buffer.write(b'\x2C\x00\x00\x00\x00')
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(b'\x00')

# Image Data
sys.stdout.buffer.write(bytes([min_code_size]))

# Write compressed image data in blocks
block_size = 255
for i in range(0, len(compressed_bytes), block_size):
    block = compressed_bytes[i:i+block_size]
    sys.stdout.buffer.write(bytes([len(block)]))
    sys.stdout.buffer.write(block)

sys.stdout.buffer.write(b'\x00')  # End of image data

# Trailer
sys.stdout.buffer.write(b'\x3B')

python triangle_gif.py > output.gif

import sys

# GIF header and logical screen descriptor
gif_header = b'GIF89a'
width, height = 200, 200
packed_fields = 0b10010001  # Color table: yes, 2 colors, 1 bit per pixel
color_resolution = 1
background_color = 0
pixel_aspect_ratio = 0

# Global color table
white = [255, 255, 255]
red = [255, 0, 0]

# Image data
image_data = bytearray([0] * (width * height // 8))

# Draw triangle
for y in range(height):
    for x in range(width):
        if (y >= 100 and x >= 100 - (y - 100) and x <= 100 + (y - 100)):
            byte_index = (y * width + x) // 8
            bit_index = 7 - ((y * width + x) % 8)
            image_data[byte_index] |= (1 << bit_index)

# LZW compress image data
def lzw_compress(data):
    dict_size = 4
    dictionary = {(i,): i for i in range(dict_size)}
    result = []
    w = ()
    for pixel in data:
        wc = w + (pixel,)
        if wc in dictionary:
            w = wc
        else:
            result.append(dictionary[w])
            dictionary[wc] = dict_size
            dict_size += 1
            w = (pixel,)
    if w:
        result.append(dictionary[w])
    return result

compressed = lzw_compress([b for byte in image_data for b in f'{byte:08b}'])

# Convert compressed data to bytes
min_code_size = 2
compressed_bytes = bytearray()
current_byte = 0
bit_count = 0

for code in compressed:
    current_byte |= (code << bit_count)
    bit_count += min_code_size + 1
    while bit_count >= 8:
        compressed_bytes.append(current_byte & 0xFF)
        current_byte >>= 8
        bit_count -= 8

if bit_count > 0:
    compressed_bytes.append(current_byte)

# Write GIF to stdout
sys.stdout.buffer.write(gif_header)
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([packed_fields, background_color, pixel_aspect_ratio]))

# Global Color Table
for color in [white, red]:
    sys.stdout.buffer.write(bytes(color))

# Image Descriptor
sys.stdout.buffer.write(b'\x2C\x00\x00\x00\x00')
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(b'\x00')

# Image Data
sys.stdout.buffer.write(bytes([min_code_size]))

# Write compressed image data in blocks
block_size = 255
for i in range(0, len(compressed_bytes), block_size):
    block = compressed_bytes[i:i+block_size]
    sys.stdout.buffer.write(bytes([len(block)]))
    sys.stdout.buffer.write(block)

sys.stdout.buffer.write(b'\x00')  # End of image data

# Trailer
sys.stdout.buffer.write(b'\x3B')

import sys

# GIF header and logical screen descriptor
gif_header = b'GIF89a'
width, height = 200, 200
packed_fields = 0b10010001  # Color table: yes, 2 colors, 1 bit per pixel
color_resolution = 1
background_color = 0
pixel_aspect_ratio = 0

# Global color table
white = [255, 255, 255]
red = [255, 0, 0]

# Image data
image_data = bytearray([0] * (width * height // 8))

# Draw triangle
for y in range(height):
    for x in range(width):
        if (y >= 100 and x >= 100 - (y - 100) and x <= 100 + (y - 100)):
            byte_index = (y * width + x) // 8
            bit_index = 7 - ((y * width + x) % 8)
            image_data[byte_index] |= (1 << bit_index)

# LZW compress image data
def lzw_compress(data):
    dict_size = 4
    dictionary = {(i,): i for i in range(dict_size)}
    result = []
    w = ()
    for pixel in data:
        wc = w + (pixel,)
        if wc in dictionary:
            w = wc
        else:
            result.append(dictionary[w])
            dictionary[wc] = dict_size
            dict_size += 1
            w = (pixel,)
    if w:
        result.append(dictionary[w])
    return result

compressed = lzw_compress([b for byte in image_data for b in f'{byte:08b}'])

# Convert compressed data to bytes
min_code_size = 2
compressed_bytes = bytearray()
current_byte = 0
bit_count = 0

for code in compressed:
    current_byte |= (code << bit_count)
    bit_count += min_code_size + 1
    while bit_count >= 8:
        compressed_bytes.append(current_byte & 0xFF)
        current_byte >>= 8
        bit_count -= 8

if bit_count > 0:
    compressed_bytes.append(current_byte)

# Write GIF to stdout
sys.stdout.buffer.write(gif_header)
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([packed_fields, background_color, pixel_aspect_ratio]))

# Global Color Table
for color in [white, red]:
    sys.stdout.buffer.write(bytes(color))

# Image Descriptor
sys.stdout.buffer.write(b'\x2C\x00\x00\x00\x00')
sys.stdout.buffer.write(bytes([width & 0xFF, (width >> 8) & 0xFF]))
sys.stdout.buffer.write(bytes([height & 0xFF, (height >> 8) & 0xFF]))
sys.stdout.buffer.write(b'\x00')

# Image Data
sys.stdout.buffer.write(bytes([min_code_size]))

# Write compressed image data in blocks
block_size = 255
for i in range(0, len(compressed_bytes), block_size):
    block = compressed_bytes[i:i+block_size]
    sys.stdout.buffer.write(bytes([len(block)]))
    sys.stdout.buffer.write(block)

sys.stdout.buffer.write(b'\x00')  # End of image data

# Trailer
sys.stdout.buffer.write(b'\x3B')

import sys

def write_int(value, bytes):
    return value.to_bytes(bytes, byteorder='little')

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_int(width, 2) + write_int(height, 2)
lsd += bytes([0xF7, 0x00, 0x00])  # Color table info

# Global Color Table
gct = write_color(255, 255, 255)  # White (background)
gct += write_color(255, 0, 0)     # Red (triangle)
gct += b'\x00' * (768 - 6)        # Pad to 256 colors

# Graphics Control Extension
gce = b'\x21\xF9\x04\x00\x00\x00\x00\x00'

# Image Descriptor
img_desc = b'\x2C\x00\x00\x00\x00'
img_desc += write_int(width, 2) + write_int(height, 2)
img_desc += b'\x00'

# Image Data
min_code_size = b'\x08'
clear_code = 0x100
end_of_info = 0x101

def lzw_encode(data):
    code_table = {bytes([i]): i for i in range(256)}
    next_code = clear_code + 2
    buffer = b''
    code_size = 9
    bit_buffer = 0
    bit_count = 0
    output = bytearray()

    def write_code(code):
        nonlocal bit_buffer, bit_count, output
        bit_buffer |= code << bit_count
        bit_count += code_size
        while bit_count >= 8:
            output.append(bit_buffer & 0xFF)
            bit_buffer >>= 8
            bit_count -= 8

    write_code(clear_code)

    for byte in data:
        buffer += bytes([byte])
        if buffer in code_table:
            continue
        write_code(code_table[buffer[:-1]])
        if next_code < 4096:
            code_table[buffer] = next_code
            next_code += 1
            if next_code.bit_length() > code_size:
                code_size += 1
        buffer = bytes([byte])

    if buffer:
        write_code(code_table[buffer])
    write_code(end_of_info)

    if bit_count > 0:
        output.append(bit_buffer & 0xFF)

    return output

image_data = bytearray(width * height)
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            image_data[y * width + x] = 1
        else:
            image_data[y * width + x] = 0

compressed_data = lzw_encode(image_data)
block_size = 255
data_blocks = b''
for i in range(0, len(compressed_data), block_size):
    chunk = compressed_data[i:i+block_size]
    data_blocks += bytes([len(chunk)]) + chunk
data_blocks += b'\x00'

# Trailer
trailer = b'\x3B'

# Write GIF to stdout
sys.stdout.buffer.write(header + lsd + gct + gce + img_desc + min_code_size + data_blocks + trailer)

python your_soln.py > /tmp/a.gif

import sys

def write_int(value, bytes):
    return value.to_bytes(bytes, byteorder='little')

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_int(width, 2) + write_int(height, 2)
lsd += bytes([0xF7, 0x00, 0x00])  # Color table info

# Global Color Table
gct = write_color(255, 255, 255)  # White (background)
gct += write_color(255, 0, 0)     # Red (triangle)
gct += b'\x00' * (768 - 6)        # Pad to 256 colors

# Graphics Control Extension
gce = b'\x21\xF9\x04\x00\x00\x00\x00\x00'

# Image Descriptor
img_desc = b'\x2C\x00\x00\x00\x00'
img_desc += write_int(width, 2) + write_int(height, 2)
img_desc += b'\x00'

# Image Data
min_code_size = b'\x08'
clear_code = 0x100
end_of_info = 0x101

def lzw_encode(data):
    code_table = {bytes([i]): i for i in range(256)}
    next_code = clear_code + 2
    buffer = b''
    code_size = 9
    bit_buffer = 0
    bit_count = 0
    output = bytearray()

    def write_code(code):
        nonlocal bit_buffer, bit_count, output
        bit_buffer |= code << bit_count
        bit_count += code_size
        while bit_count >= 8:
            output.append(bit_buffer & 0xFF)
            bit_buffer >>= 8
            bit_count -= 8

    write_code(clear_code)

    for byte in data:
        buffer += bytes([byte])
        if buffer in code_table:
            continue
        write_code(code_table[buffer[:-1]])
        if next_code < 4096:
            code_table[buffer] = next_code
            next_code += 1
            if next_code.bit_length() > code_size:
                code_size += 1
        buffer = bytes([byte])

    if buffer:
        write_code(code_table[buffer])
    write_code(end_of_info)

    if bit_count > 0:
        output.append(bit_buffer & 0xFF)

    return output

image_data = bytearray(width * height)
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            image_data[y * width + x] = 1
        else:
            image_data[y * width + x] = 0

compressed_data = lzw_encode(image_data)
block_size = 255
data_blocks = b''
for i in range(0, len(compressed_data), block_size):
    chunk = compressed_data[i:i+block_size]
    data_blocks += bytes([len(chunk)]) + chunk
data_blocks += b'\x00'

# Trailer
trailer = b'\x3B'

# Write GIF to stdout
sys.stdout.buffer.write(header + lsd + gct + gce + img_desc + min_code_size + data_blocks + trailer)

import sys

def write_int(value, bytes):
    return value.to_bytes(bytes, byteorder='little')

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_int(width, 2) + write_int(height, 2)
lsd += bytes([0xF7, 0x00, 0x00])  # Color table info

# Global Color Table
gct = write_color(255, 255, 255)  # White (background)
gct += write_color(255, 0, 0)     # Red (triangle)
gct += b'\x00' * (768 - 6)        # Pad to 256 colors

# Graphics Control Extension
gce = b'\x21\xF9\x04\x00\x00\x00\x00\x00'

# Image Descriptor
img_desc = b'\x2C\x00\x00\x00\x00'
img_desc += write_int(width, 2) + write_int(height, 2)
img_desc += b'\x00'

# Image Data
min_code_size = b'\x08'
clear_code = 0x100
end_of_info = 0x101

def lzw_encode(data):
    code_table = {bytes([i]): i for i in range(256)}
    next_code = clear_code + 2
    buffer = b''
    code_size = 9
    bit_buffer = 0
    bit_count = 0
    output = bytearray()

    def write_code(code):
        nonlocal bit_buffer, bit_count, output
        bit_buffer |= code << bit_count
        bit_count += code_size
        while bit_count >= 8:
            output.append(bit_buffer & 0xFF)
            bit_buffer >>= 8
            bit_count -= 8

    write_code(clear_code)

    for byte in data:
        buffer += bytes([byte])
        if buffer in code_table:
            continue
        write_code(code_table[buffer[:-1]])
        if next_code < 4096:
            code_table[buffer] = next_code
            next_code += 1
            if next_code.bit_length() > code_size:
                code_size += 1
        buffer = bytes([byte])

    if buffer:
        write_code(code_table[buffer])
    write_code(end_of_info)

    if bit_count > 0:
        output.append(bit_buffer & 0xFF)

    return output

image_data = bytearray(width * height)
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            image_data[y * width + x] = 1
        else:
            image_data[y * width + x] = 0

compressed_data = lzw_encode(image_data)
block_size = 255
data_blocks = b''
for i in range(0, len(compressed_data), block_size):
    chunk = compressed_data[i:i+block_size]
    data_blocks += bytes([len(chunk)]) + chunk
data_blocks += b'\x00'

# Trailer
trailer = b'\x3B'

# Write GIF to stdout
sys.stdout.buffer.write(header + lsd + gct + gce + img_desc + min_code_size + data_blocks + trailer)

import sys

def write_int16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
gif_header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
packed_field = 0b10010001  # Color table present, 2 colors
gif_lsd = write_int16(width) + write_int16(height) + bytes([packed_field, 0, 0])

# Global Color Table
white = write_color(255, 255, 255)
red = write_color(255, 0, 0)
gif_gct = white + red

# Image Descriptor
gif_id = b'\x2C\x00\x00\x00\x00' + write_int16(width) + write_int16(height) + b'\x00'

# Image Data
def lzw_encode(pixels):
    code_size = 2
    clear_code = 4
    end_code = 5
    next_code = 6
    max_code = 7
    dict_size = 6

    output = bytearray([code_size])
    buffer = 0
    bits = 0

    def output_code(code):
        nonlocal buffer, bits
        buffer |= code << bits
        bits += code_size
        while bits >= 8:
            output.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8

    output_code(clear_code)

    for pixel in pixels:
        output_code(pixel)

        if next_code == max_code and code_size < 12:
            code_size += 1
            max_code = (1 << code_size) - 1

        next_code += 1
        if next_code > max_code:
            output_code(clear_code)
            code_size = 2
            max_code = 7
            next_code = 6
            dict_size = 6

    output_code(end_code)
    if bits > 0:
        output.append(buffer & 0xFF)

    return bytes([len(output)]) + output + b'\x00'

pixels = []
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            pixels.append(1)  # Red
        else:
            pixels.append(0)  # White

gif_data = lzw_encode(pixels)

# Trailer
gif_trailer = b'\x3B'

# Combine all parts and write to stdout
sys.stdout.buffer.write(gif_header + gif_lsd + gif_gct + gif_id + gif_data + gif_trailer)

python triangle_gif.py > /tmp/a.gif

import sys

def write_int16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
gif_header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
packed_field = 0b10010001  # Color table present, 2 colors
gif_lsd = write_int16(width) + write_int16(height) + bytes([packed_field, 0, 0])

# Global Color Table
white = write_color(255, 255, 255)
red = write_color(255, 0, 0)
gif_gct = white + red

# Image Descriptor
gif_id = b'\x2C\x00\x00\x00\x00' + write_int16(width) + write_int16(height) + b'\x00'

# Image Data
def lzw_encode(pixels):
    code_size = 2
    clear_code = 4
    end_code = 5
    next_code = 6
    max_code = 7
    dict_size = 6

    output = bytearray([code_size])
    buffer = 0
    bits = 0

    def output_code(code):
        nonlocal buffer, bits
        buffer |= code << bits
        bits += code_size
        while bits >= 8:
            output.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8

    output_code(clear_code)

    for pixel in pixels:
        output_code(pixel)

        if next_code == max_code and code_size < 12:
            code_size += 1
            max_code = (1 << code_size) - 1

        next_code += 1
        if next_code > max_code:
            output_code(clear_code)
            code_size = 2
            max_code = 7
            next_code = 6
            dict_size = 6

    output_code(end_code)
    if bits > 0:
        output.append(buffer & 0xFF)

    return bytes([len(output)]) + output + b'\x00'

pixels = []
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            pixels.append(1)  # Red
        else:
            pixels.append(0)  # White

gif_data = lzw_encode(pixels)

# Trailer
gif_trailer = b'\x3B'

# Combine all parts and write to stdout
sys.stdout.buffer.write(gif_header + gif_lsd + gif_gct + gif_id + gif_data + gif_trailer)

import sys

def write_int16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
gif_header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
packed_field = 0b10010001  # Color table present, 2 colors
gif_lsd = write_int16(width) + write_int16(height) + bytes([packed_field, 0, 0])

# Global Color Table
white = write_color(255, 255, 255)
red = write_color(255, 0, 0)
gif_gct = white + red

# Image Descriptor
gif_id = b'\x2C\x00\x00\x00\x00' + write_int16(width) + write_int16(height) + b'\x00'

# Image Data
def lzw_encode(pixels):
    code_size = 2
    clear_code = 4
    end_code = 5
    next_code = 6
    max_code = 7
    dict_size = 6

    output = bytearray([code_size])
    buffer = 0
    bits = 0

    def output_code(code):
        nonlocal buffer, bits
        buffer |= code << bits
        bits += code_size
        while bits >= 8:
            output.append(buffer & 0xFF)
            buffer >>= 8
            bits -= 8

    output_code(clear_code)

    for pixel in pixels:
        output_code(pixel)

        if next_code == max_code and code_size < 12:
            code_size += 1
            max_code = (1 << code_size) - 1

        next_code += 1
        if next_code > max_code:
            output_code(clear_code)
            code_size = 2
            max_code = 7
            next_code = 6
            dict_size = 6

    output_code(end_code)
    if bits > 0:
        output.append(buffer & 0xFF)

    return bytes([len(output)]) + output + b'\x00'

pixels = []
for y in range(height):
    for x in range(width):
        if y > x and y < 200 - x:
            pixels.append(1)  # Red
        else:
            pixels.append(0)  # White

gif_data = lzw_encode(pixels)

# Trailer
gif_trailer = b'\x3B'

# Combine all parts and write to stdout
sys.stdout.buffer.write(gif_header + gif_lsd + gif_gct + gif_id + gif_data + gif_trailer)

import sys

def write_uint16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_uint16(width) + write_uint16(height) + b'\xF7\x00\x00'

# Global Color Table
gct = b''.join([
    write_color(255, 255, 255),  # White (background)
    write_color(255, 0, 0),      # Red (triangle color)
    *[write_color(0, 0, 0) for _ in range(254)]  # Padding
])

# Image Descriptor
img_descriptor = b'\x2C\x00\x00\x00\x00' + write_uint16(width) + write_uint16(height) + b'\x00'

# Image Data
def lzw_compress(data):
    clear_code = 4
    end_code = 5
    code_size = 3
    next_code = 6
    code_table = {(i,): i for i in range(4)}
    
    output = [clear_code]
    current_sequence = ()
    
    for pixel in data:
        new_sequence = current_sequence + (pixel,)
        if new_sequence in code_table:
            current_sequence = new_sequence
        else:
            output.append(code_table[current_sequence])
            code_table[new_sequence] = next_code
            next_code += 1
            current_sequence = (pixel,)
            
            if next_code == 2**code_size:
                code_size += 1
            
            if next_code == 4096:
                output.append(clear_code)
                code_size = 3
                next_code = 6
                code_table = {(i,): i for i in range(4)}
    
    if current_sequence:
        output.append(code_table[current_sequence])
    
    output.append(end_code)
    return output

def triangle_pixel(x, y):
    if y >= x and y >= -x + 199 and y <= 199:
        return 1
    return 0

image_data = [triangle_pixel(x, y) for y in range(height) for x in range(width)]
compressed_data = lzw_compress(image_data)

# Convert compressed data to bytes
bit_stream = ''.join(f'{code:0{max(3, (code.bit_length() + 7) // 8 * 8)}b}' for code in compressed_data)
byte_stream = [int(bit_stream[i:i+8], 2) for i in range(0, len(bit_stream), 8)]

# Add LZW minimum code size
img_data = b'\x03' + bytes([len(byte_stream)]) + bytes(byte_stream) + b'\x00'

# Trailer
trailer = b'\x3B'

# Combine all parts
gif_data = header + lsd + gct + img_descriptor + img_data + trailer

# Write to stdout
sys.stdout.buffer.write(gif_data)

python triangle_gif.py > /tmp/a.gif

import sys

def write_uint16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_uint16(width) + write_uint16(height) + b'\xF7\x00\x00'

# Global Color Table
gct = b''.join([
    write_color(255, 255, 255),  # White (background)
    write_color(255, 0, 0),      # Red (triangle color)
    *[write_color(0, 0, 0) for _ in range(254)]  # Padding
])

# Image Descriptor
img_descriptor = b'\x2C\x00\x00\x00\x00' + write_uint16(width) + write_uint16(height) + b'\x00'

# Image Data
def lzw_compress(data):
    clear_code = 4
    end_code = 5
    code_size = 3
    next_code = 6
    code_table = {(i,): i for i in range(4)}
    
    output = [clear_code]
    current_sequence = ()
    
    for pixel in data:
        new_sequence = current_sequence + (pixel,)
        if new_sequence in code_table:
            current_sequence = new_sequence
        else:
            output.append(code_table[current_sequence])
            code_table[new_sequence] = next_code
            next_code += 1
            current_sequence = (pixel,)
            
            if next_code == 2**code_size:
                code_size += 1
            
            if next_code == 4096:
                output.append(clear_code)
                code_size = 3
                next_code = 6
                code_table = {(i,): i for i in range(4)}
    
    if current_sequence:
        output.append(code_table[current_sequence])
    
    output.append(end_code)
    return output

def triangle_pixel(x, y):
    if y >= x and y >= -x + 199 and y <= 199:
        return 1
    return 0

image_data = [triangle_pixel(x, y) for y in range(height) for x in range(width)]
compressed_data = lzw_compress(image_data)

# Convert compressed data to bytes
bit_stream = ''.join(f'{code:0{max(3, (code.bit_length() + 7) // 8 * 8)}b}' for code in compressed_data)
byte_stream = [int(bit_stream[i:i+8], 2) for i in range(0, len(bit_stream), 8)]

# Add LZW minimum code size
img_data = b'\x03' + bytes([len(byte_stream)]) + bytes(byte_stream) + b'\x00'

# Trailer
trailer = b'\x3B'

# Combine all parts
gif_data = header + lsd + gct + img_descriptor + img_data + trailer

# Write to stdout
sys.stdout.buffer.write(gif_data)

import sys

def write_uint16(value):
    return bytes([value & 0xFF, (value >> 8) & 0xFF])

def write_color(r, g, b):
    return bytes([r, g, b])

# GIF header
header = b'GIF89a'

# Logical Screen Descriptor
width, height = 200, 200
lsd = write_uint16(width) + write_uint16(height) + b'\xF7\x00\x00'

# Global Color Table
gct = b''.join([
    write_color(255, 255, 255),  # White (background)
    write_color(255, 0, 0),      # Red (triangle color)
    *[write_color(0, 0, 0) for _ in range(254)]  # Padding
])

# Image Descriptor
img_descriptor = b'\x2C\x00\x00\x00\x00' + write_uint16(width) + write_uint16(height) + b'\x00'

# Image Data
def lzw_compress(data):
    clear_code = 4
    end_code = 5
    code_size = 3
    next_code = 6
    code_table = {(i,): i for i in range(4)}
    
    output = [clear_code]
    current_sequence = ()
    
    for pixel in data:
        new_sequence = current_sequence + (pixel,)
        if new_sequence in code_table:
            current_sequence = new_sequence
        else:
            output.append(code_table[current_sequence])
            code_table[new_sequence] = next_code
            next_code += 1
            current_sequence = (pixel,)
            
            if next_code == 2**code_size:
                code_size += 1
            
            if next_code == 4096:
                output.append(clear_code)
                code_size = 3
                next_code = 6
                code_table = {(i,): i for i in range(4)}
    
    if current_sequence:
        output.append(code_table[current_sequence])
    
    output.append(end_code)
    return output

def triangle_pixel(x, y):
    if y >= x and y >= -x + 199 and y <= 199:
        return 1
    return 0

image_data = [triangle_pixel(x, y) for y in range(height) for x in range(width)]
compressed_data = lzw_compress(image_data)

# Convert compressed data to bytes
bit_stream = ''.join(f'{code:0{max(3, (code.bit_length() + 7) // 8 * 8)}b}' for code in compressed_data)
byte_stream = [int(bit_stream[i:i+8], 2) for i in range(0, len(bit_stream), 8)]

# Add LZW minimum code size
img_data = b'\x03' + bytes([len(byte_stream)]) + bytes(byte_stream) + b'\x00'

# Trailer
trailer = b'\x3B'

# Combine all parts
gif_data = header + lsd + gct + img_descriptor + img_data + trailer

# Write to stdout
sys.stdout.buffer.write(gif_data)