def write_gif_header():
    # GIF89a header
    return b'GIF89a' + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\xF7\x00\x00'


def write_color_table():
    # Color table: white (255, 255, 255) and red (255, 0, 0)
    return bytes([
        255, 255, 255,  # White
        255, 0, 0      # Red
    ])


def write_image_data():
    # Image descriptor
    return b'\x2C' + (0).to_bytes(2, 'little') + (0).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\x00'


def create_triangle_image():
    # Create a 200x200 pixel image with a red triangle on a white background
    image_data = bytearray(200 * 200)  # Initialize with white (0)

    # Coordinates for the triangle
    height = 150  # Height of the triangle
    base_width = 100  # Base width of the triangle
    apex_x = 100
    apex_y = 25

    # Draw the triangle
    for y in range(height):
        for x in range(apex_x - (base_width // 2), apex_x + (base_width // 2) + 1):
            # Condition for the triangle
            if (x >= apex_x - (y * base_width // height)) and (x <= apex_x + (y * base_width // height)):
                image_data[y * 200 + x] = 1  # Set red color index

    # Encode the image data
    lzw_encoded_data = lzw_encode(image_data)

    return lzw_encoded_data


def lzw_encode(data):
    # Simple LZW encoding for the image data
    # This is a placeholder for the actual LZW encoding
    # In this mock example, we will just return the raw data for simplicity
    # Note: Proper LZW encoding is required for a valid GIF
    return b'\x08' + data  # Using a single byte to represent the LZW minimum code size


def write_gif_trailer():
    # GIF trailer
    return b'\x3B'


def main():
    gif_data = (
        write_gif_header() +
        write_color_table() +
        write_image_data() +
        create_triangle_image() +
        write_gif_trailer()
    )
    
    # Output the GIF to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    main()

def write_gif_header():
    # GIF89a header
    return b'GIF89a' + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\xF7\x00\x00'


def write_color_table():
    # Color table: white (255, 255, 255) and red (255, 0, 0)
    return bytes([
        255, 255, 255,  # White
        255, 0, 0      # Red
    ])


def write_image_data():
    # Image descriptor
    return b'\x2C' + (0).to_bytes(2, 'little') + (0).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\x00'


def create_triangle_image():
    # Create a 200x200 pixel image with a red triangle on a white background
    image_data = bytearray(200 * 200)  # Initialize with white (0)

    # Coordinates for the triangle
    height = 150  # Height of the triangle
    base_width = 100  # Base width of the triangle
    apex_x = 100
    apex_y = 25

    # Draw the triangle
    for y in range(height):
        for x in range(apex_x - (base_width // 2), apex_x + (base_width // 2) + 1):
            # Condition for the triangle
            if (x >= apex_x - (y * base_width // height)) and (x <= apex_x + (y * base_width // height)):
                image_data[y * 200 + x] = 1  # Set red color index

    # Encode the image data
    lzw_encoded_data = lzw_encode(image_data)

    return lzw_encoded_data


def lzw_encode(data):
    # Simple LZW encoding for the image data
    # This is a placeholder for the actual LZW encoding
    # In this mock example, we will just return the raw data for simplicity
    # Note: Proper LZW encoding is required for a valid GIF
    return b'\x08' + data  # Using a single byte to represent the LZW minimum code size


def write_gif_trailer():
    # GIF trailer
    return b'\x3B'


def main():
    gif_data = (
        write_gif_header() +
        write_color_table() +
        write_image_data() +
        create_triangle_image() +
        write_gif_trailer()
    )
    
    # Output the GIF to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    main()

def write_gif_header():
    # GIF89a header
    return b'GIF89a' + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\xF7\x00\x00'


def write_color_table():
    # Color table: white (255, 255, 255) and red (255, 0, 0)
    return bytes([
        255, 255, 255,  # White
        255, 0, 0      # Red
    ])


def write_image_data():
    # Image descriptor
    return b'\x2C' + (0).to_bytes(2, 'little') + (0).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + (200).to_bytes(2, 'little') + b'\x00'


def create_triangle_image():
    # Create a 200x200 pixel image with a red triangle on a white background
    image_data = bytearray(200 * 200)  # Initialize with white (0)

    # Coordinates for the triangle
    height = 150  # Height of the triangle
    base_width = 100  # Base width of the triangle
    apex_x = 100
    apex_y = 25

    # Draw the triangle
    for y in range(height):
        for x in range(apex_x - (base_width // 2), apex_x + (base_width // 2) + 1):
            # Condition for the triangle
            if (x >= apex_x - (y * base_width // height)) and (x <= apex_x + (y * base_width // height)):
                image_data[y * 200 + x] = 1  # Set red color index

    # Encode the image data
    lzw_encoded_data = lzw_encode(image_data)

    return lzw_encoded_data


def lzw_encode(data):
    # Simple LZW encoding for the image data
    # This is a placeholder for the actual LZW encoding
    # In this mock example, we will just return the raw data for simplicity
    # Note: Proper LZW encoding is required for a valid GIF
    return b'\x08' + data  # Using a single byte to represent the LZW minimum code size


def write_gif_trailer():
    # GIF trailer
    return b'\x3B'


def main():
    gif_data = (
        write_gif_header() +
        write_color_table() +
        write_image_data() +
        create_triangle_image() +
        write_gif_trailer()
    )
    
    # Output the GIF to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    main()

def write_gif():
    # GIF header
    header = b'GIF89a'  # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + b'\xF7' + b'\x00' + b'\x00'

    # Global Color Table (White and Red)
    color_table = b'\xFF\xFF\xFF'  # White
    color_table += b'\xFF\x00\x00'  # Red

    # Image Descriptor
    image_descriptor = b'\x2C'  # Image Separator
    image_descriptor += b'\x00\x00'  # Image position (0,0)
    image_descriptor += width.to_bytes(2, 'little')  # Image width
    image_descriptor += height.to_bytes(2, 'little')  # Image height
    image_descriptor += b'\x00'  # No local color table, no interlace

    # LZW Minimum Code Size
    lzw_min_code_size = 8

    # Image data (triangle)
    # Using a simple run-length encoding for the triangle
    # We will represent the triangle with a simple rasterization method.
    triangle_data = [0] * (width * height)  # 0 for white, 1 for red

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if x >= 100 * (y / 200) and x <= 200 - 100 * (y / 200):
                triangle_data[y * width + x] = 1  # Fill red in the triangle area

    # Convert triangle_data to LZW compressed format
    image_data = bytearray()
    current_color = -1
    run_length = 0

    for value in triangle_data:
        if value == current_color:
            run_length += 1
            if run_length == 255:  # Max run length is 255
                image_data.append(current_color)
                image_data.append(run_length)
                run_length = 0
        else:
            if current_color != -1:
                image_data.append(current_color)
                image_data.append(run_length)
            current_color = value
            run_length = 1

    if current_color != -1:
        image_data.append(current_color)
        image_data.append(run_length)

    # Ending the image data with a terminator
    image_data.append(0x00)

    # Construct the complete GIF
    gif_data = (
        header +
        logical_screen_descriptor +
        color_table +
        image_descriptor +
        bytes([lzw_min_code_size]) +
        bytes(image_data) +
        b'\x3B'  # GIF Trailer
    )

    # Output the GIF data to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    write_gif()

python draw_triangle_gif.py > /tmp/a.gif

def write_gif():
    # GIF header
    header = b'GIF89a'  # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + b'\xF7' + b'\x00' + b'\x00'

    # Global Color Table (White and Red)
    color_table = b'\xFF\xFF\xFF'  # White
    color_table += b'\xFF\x00\x00'  # Red

    # Image Descriptor
    image_descriptor = b'\x2C'  # Image Separator
    image_descriptor += b'\x00\x00'  # Image position (0,0)
    image_descriptor += width.to_bytes(2, 'little')  # Image width
    image_descriptor += height.to_bytes(2, 'little')  # Image height
    image_descriptor += b'\x00'  # No local color table, no interlace

    # LZW Minimum Code Size
    lzw_min_code_size = 8

    # Image data (triangle)
    # Using a simple run-length encoding for the triangle
    # We will represent the triangle with a simple rasterization method.
    triangle_data = [0] * (width * height)  # 0 for white, 1 for red

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if x >= 100 * (y / 200) and x <= 200 - 100 * (y / 200):
                triangle_data[y * width + x] = 1  # Fill red in the triangle area

    # Convert triangle_data to LZW compressed format
    image_data = bytearray()
    current_color = -1
    run_length = 0

    for value in triangle_data:
        if value == current_color:
            run_length += 1
            if run_length == 255:  # Max run length is 255
                image_data.append(current_color)
                image_data.append(run_length)
                run_length = 0
        else:
            if current_color != -1:
                image_data.append(current_color)
                image_data.append(run_length)
            current_color = value
            run_length = 1

    if current_color != -1:
        image_data.append(current_color)
        image_data.append(run_length)

    # Ending the image data with a terminator
    image_data.append(0x00)

    # Construct the complete GIF
    gif_data = (
        header +
        logical_screen_descriptor +
        color_table +
        image_descriptor +
        bytes([lzw_min_code_size]) +
        bytes(image_data) +
        b'\x3B'  # GIF Trailer
    )

    # Output the GIF data to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    header = b'GIF89a'  # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + b'\xF7' + b'\x00' + b'\x00'

    # Global Color Table (White and Red)
    color_table = b'\xFF\xFF\xFF'  # White
    color_table += b'\xFF\x00\x00'  # Red

    # Image Descriptor
    image_descriptor = b'\x2C'  # Image Separator
    image_descriptor += b'\x00\x00'  # Image position (0,0)
    image_descriptor += width.to_bytes(2, 'little')  # Image width
    image_descriptor += height.to_bytes(2, 'little')  # Image height
    image_descriptor += b'\x00'  # No local color table, no interlace

    # LZW Minimum Code Size
    lzw_min_code_size = 8

    # Image data (triangle)
    # Using a simple run-length encoding for the triangle
    # We will represent the triangle with a simple rasterization method.
    triangle_data = [0] * (width * height)  # 0 for white, 1 for red

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if x >= 100 * (y / 200) and x <= 200 - 100 * (y / 200):
                triangle_data[y * width + x] = 1  # Fill red in the triangle area

    # Convert triangle_data to LZW compressed format
    image_data = bytearray()
    current_color = -1
    run_length = 0

    for value in triangle_data:
        if value == current_color:
            run_length += 1
            if run_length == 255:  # Max run length is 255
                image_data.append(current_color)
                image_data.append(run_length)
                run_length = 0
        else:
            if current_color != -1:
                image_data.append(current_color)
                image_data.append(run_length)
            current_color = value
            run_length = 1

    if current_color != -1:
        image_data.append(current_color)
        image_data.append(run_length)

    # Ending the image data with a terminator
    image_data.append(0x00)

    # Construct the complete GIF
    gif_data = (
        header +
        logical_screen_descriptor +
        color_table +
        image_descriptor +
        bytes([lzw_min_code_size]) +
        bytes(image_data) +
        b'\x3B'  # GIF Trailer
    )

    # Output the GIF data to stdout
    import sys
    sys.stdout.buffer.write(gif_data)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # Signature + version
    width = 200
    height = 200
    packed_fields = b'\xF7'  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = 0  # White background
    pixel_aspect_ratio = 0  # No aspect ratio
    global_color_table = b'\xFF\xFF\xFF'  # White
    global_color_table += b'\xFF\x00\x00'  # Red

    # Image descriptor
    image_descriptor = b'\x2C'  # Image Separator
    lct_flag = b'\x00'  # Local Color Table Flag
    left = b'\x00\x00'  # Image Left Position
    top = b'\x00\x00'  # Image Top Position
    image_width = width.to_bytes(2, byteorder='little')
    image_height = height.to_bytes(2, byteorder='little')
    packed_fields_image = b'\x00'  # No Local Color Table, Interlaced

    # Image data (RLE encoded)
    image_data = bytearray()
    for y in range(height):
        for x in range(width):
            if (y >= 100 and (x >= 100 - y) and (x <= 100 + y)) or (y <= 100 and (x >= 100 - (200 - y)) and (x <= 100 + (200 - y))):
                image_data.append(1)  # Red
            else:
                image_data.append(0)  # White

    # LZW Minimum Code Size
    lzw_min_code_size = b'\x08'
    lzw_data = bytearray()
    lzw_data.append(len(image_data))
    lzw_data.extend(image_data)

    # GIF trailer
    gif_trailer = b'\x3B'  # Trailer

    # Combine all parts
    gif_data = (
        gif_header +
        width.to_bytes(2, byteorder='little') +
        height.to_bytes(2, byteorder='little') +
        packed_fields +
        background_color_index.to_bytes(1, byteorder='little') +
        pixel_aspect_ratio +
        global_color_table +
        image_descriptor +
        left + top +
        image_width + image_height +
        packed_fields_image +
        lzw_min_code_size +
        lzw_data +
        gif_trailer
    )

    return gif_data

if __name__ == "__main__":
    gif_bytes = write_gif()
    print(gif_bytes)

   python your_soln.py > /tmp/a.gif
   

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # Signature + version
    width = 200
    height = 200
    packed_fields = b'\xF7'  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = 0  # White background
    pixel_aspect_ratio = 0  # No aspect ratio
    global_color_table = b'\xFF\xFF\xFF'  # White
    global_color_table += b'\xFF\x00\x00'  # Red

    # Image descriptor
    image_descriptor = b'\x2C'  # Image Separator
    lct_flag = b'\x00'  # Local Color Table Flag
    left = b'\x00\x00'  # Image Left Position
    top = b'\x00\x00'  # Image Top Position
    image_width = width.to_bytes(2, byteorder='little')
    image_height = height.to_bytes(2, byteorder='little')
    packed_fields_image = b'\x00'  # No Local Color Table, Interlaced

    # Image data (RLE encoded)
    image_data = bytearray()
    for y in range(height):
        for x in range(width):
            if (y >= 100 and (x >= 100 - y) and (x <= 100 + y)) or (y <= 100 and (x >= 100 - (200 - y)) and (x <= 100 + (200 - y))):
                image_data.append(1)  # Red
            else:
                image_data.append(0)  # White

    # LZW Minimum Code Size
    lzw_min_code_size = b'\x08'
    lzw_data = bytearray()
    lzw_data.append(len(image_data))
    lzw_data.extend(image_data)

    # GIF trailer
    gif_trailer = b'\x3B'  # Trailer

    # Combine all parts
    gif_data = (
        gif_header +
        width.to_bytes(2, byteorder='little') +
        height.to_bytes(2, byteorder='little') +
        packed_fields +
        background_color_index.to_bytes(1, byteorder='little') +
        pixel_aspect_ratio +
        global_color_table +
        image_descriptor +
        left + top +
        image_width + image_height +
        packed_fields_image +
        lzw_min_code_size +
        lzw_data +
        gif_trailer
    )

    return gif_data

if __name__ == "__main__":
    gif_bytes = write_gif()
    print(gif_bytes)

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # Signature + version
    width = 200
    height = 200
    packed_fields = b'\xF7'  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = 0  # White background
    pixel_aspect_ratio = 0  # No aspect ratio
    global_color_table = b'\xFF\xFF\xFF'  # White
    global_color_table += b'\xFF\x00\x00'  # Red

    # Image descriptor
    image_descriptor = b'\x2C'  # Image Separator
    lct_flag = b'\x00'  # Local Color Table Flag
    left = b'\x00\x00'  # Image Left Position
    top = b'\x00\x00'  # Image Top Position
    image_width = width.to_bytes(2, byteorder='little')
    image_height = height.to_bytes(2, byteorder='little')
    packed_fields_image = b'\x00'  # No Local Color Table, Interlaced

    # Image data (RLE encoded)
    image_data = bytearray()
    for y in range(height):
        for x in range(width):
            if (y >= 100 and (x >= 100 - y) and (x <= 100 + y)) or (y <= 100 and (x >= 100 - (200 - y)) and (x <= 100 + (200 - y))):
                image_data.append(1)  # Red
            else:
                image_data.append(0)  # White

    # LZW Minimum Code Size
    lzw_min_code_size = b'\x08'
    lzw_data = bytearray()
    lzw_data.append(len(image_data))
    lzw_data.extend(image_data)

    # GIF trailer
    gif_trailer = b'\x3B'  # Trailer

    # Combine all parts
    gif_data = (
        gif_header +
        width.to_bytes(2, byteorder='little') +
        height.to_bytes(2, byteorder='little') +
        packed_fields +
        background_color_index.to_bytes(1, byteorder='little') +
        pixel_aspect_ratio +
        global_color_table +
        image_descriptor +
        left + top +
        image_width + image_height +
        packed_fields_image +
        lzw_min_code_size +
        lzw_data +
        gif_trailer
    )

    return gif_data

if __name__ == "__main__":
    gif_bytes = write_gif()
    print(gif_bytes)

def write_gif():
    # GIF header
    gif_header = b'GIF89a'          # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little')
    packed_fields = b'\xF7'          # Global Color Table flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = b'\x00' # Background color index
    pixel_aspect_ratio = b'\x00'     # Pixel aspect ratio
    gif_header += logical_screen_descriptor + packed_fields + background_color_index + pixel_aspect_ratio

    # Global Color Table (white and red)
    # White (255, 255, 255) -> index 0
    # Red (255, 0, 0) -> index 1
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'
    gif_header += global_color_table

    # Image Descriptor
    image_separator = b'\x2C'        # Image Separator
    image_left = b'\x00\x00'         # Image Left Position
    image_top = b'\x00\x00'          # Image Top Position
    image_width = width.to_bytes(2, 'little')  # Image Width
    image_height = height.to_bytes(2, 'little') # Image Height
    local_color_table_flag = b'\x00' # No Local Color Table
    interlace_flag = b'\x00'         # No Interlacing
    sort_flag = b'\x00'              # No sorting
    reserved = b'\x00'               # Reserved
    local_color_table_size = b'\x00' # No Local Color Table

    image_descriptor = (
        image_separator +
        image_left +
        image_top +
        image_width +
        image_height +
        local_color_table_flag +
        interlace_flag +
        sort_flag +
        reserved +
        local_color_table_size
    )
    gif_header += image_descriptor

    # LZW Minimum Code Size (for the image)
    lzw_min_code_size = b'\x08'
    gif_header += lzw_min_code_size

    # LZW encoded data for the red triangle
    # This is a simple representation of the triangle in a flat encoded format
    # The triangle will be drawn manually by setting pixel data for its area
    pixels = bytearray([0] * (width * height))  # Initialize all pixels to white (index 0)

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if (y >= 100) and (y <= 200 - (x // 2)) and (x <= 200):
                pixels[y * width + x] = 1  # Set pixel to red (index 1)
    
    # LZW encoded image data (simplified for this example, this is not the actual LZW compression)
    # Here we just simulate a single block of data for the triangle
    image_data = bytearray()
    for pixel in pixels:
        image_data.append(pixel)

    # Now we need to encode the image data length
    image_data_length = len(image_data).to_bytes(1, 'little')
    gif_header += image_data_length + image_data + b'\x00'  # End of image data

    # GIF Trailer
    gif_trailer = b'\x3B'  # GIF file terminator
    gif_header += gif_trailer

    # Output the GIF data to stdout
    print(gif_header)

if __name__ == "__main__":
    write_gif()

python your_soln.py > /tmp/a.gif

def write_gif():
    # GIF header
    gif_header = b'GIF89a'          # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little')
    packed_fields = b'\xF7'          # Global Color Table flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = b'\x00' # Background color index
    pixel_aspect_ratio = b'\x00'     # Pixel aspect ratio
    gif_header += logical_screen_descriptor + packed_fields + background_color_index + pixel_aspect_ratio

    # Global Color Table (white and red)
    # White (255, 255, 255) -> index 0
    # Red (255, 0, 0) -> index 1
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'
    gif_header += global_color_table

    # Image Descriptor
    image_separator = b'\x2C'        # Image Separator
    image_left = b'\x00\x00'         # Image Left Position
    image_top = b'\x00\x00'          # Image Top Position
    image_width = width.to_bytes(2, 'little')  # Image Width
    image_height = height.to_bytes(2, 'little') # Image Height
    local_color_table_flag = b'\x00' # No Local Color Table
    interlace_flag = b'\x00'         # No Interlacing
    sort_flag = b'\x00'              # No sorting
    reserved = b'\x00'               # Reserved
    local_color_table_size = b'\x00' # No Local Color Table

    image_descriptor = (
        image_separator +
        image_left +
        image_top +
        image_width +
        image_height +
        local_color_table_flag +
        interlace_flag +
        sort_flag +
        reserved +
        local_color_table_size
    )
    gif_header += image_descriptor

    # LZW Minimum Code Size (for the image)
    lzw_min_code_size = b'\x08'
    gif_header += lzw_min_code_size

    # LZW encoded data for the red triangle
    # This is a simple representation of the triangle in a flat encoded format
    # The triangle will be drawn manually by setting pixel data for its area
    pixels = bytearray([0] * (width * height))  # Initialize all pixels to white (index 0)

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if (y >= 100) and (y <= 200 - (x // 2)) and (x <= 200):
                pixels[y * width + x] = 1  # Set pixel to red (index 1)
    
    # LZW encoded image data (simplified for this example, this is not the actual LZW compression)
    # Here we just simulate a single block of data for the triangle
    image_data = bytearray()
    for pixel in pixels:
        image_data.append(pixel)

    # Now we need to encode the image data length
    image_data_length = len(image_data).to_bytes(1, 'little')
    gif_header += image_data_length + image_data + b'\x00'  # End of image data

    # GIF Trailer
    gif_trailer = b'\x3B'  # GIF file terminator
    gif_header += gif_trailer

    # Output the GIF data to stdout
    print(gif_header)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    gif_header = b'GIF89a'          # GIF signature and version
    width = 200
    height = 200
    logical_screen_descriptor = width.to_bytes(2, 'little') + height.to_bytes(2, 'little')
    packed_fields = b'\xF7'          # Global Color Table flag, Color Resolution, Sort Flag, Size of Global Color Table
    background_color_index = b'\x00' # Background color index
    pixel_aspect_ratio = b'\x00'     # Pixel aspect ratio
    gif_header += logical_screen_descriptor + packed_fields + background_color_index + pixel_aspect_ratio

    # Global Color Table (white and red)
    # White (255, 255, 255) -> index 0
    # Red (255, 0, 0) -> index 1
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'
    gif_header += global_color_table

    # Image Descriptor
    image_separator = b'\x2C'        # Image Separator
    image_left = b'\x00\x00'         # Image Left Position
    image_top = b'\x00\x00'          # Image Top Position
    image_width = width.to_bytes(2, 'little')  # Image Width
    image_height = height.to_bytes(2, 'little') # Image Height
    local_color_table_flag = b'\x00' # No Local Color Table
    interlace_flag = b'\x00'         # No Interlacing
    sort_flag = b'\x00'              # No sorting
    reserved = b'\x00'               # Reserved
    local_color_table_size = b'\x00' # No Local Color Table

    image_descriptor = (
        image_separator +
        image_left +
        image_top +
        image_width +
        image_height +
        local_color_table_flag +
        interlace_flag +
        sort_flag +
        reserved +
        local_color_table_size
    )
    gif_header += image_descriptor

    # LZW Minimum Code Size (for the image)
    lzw_min_code_size = b'\x08'
    gif_header += lzw_min_code_size

    # LZW encoded data for the red triangle
    # This is a simple representation of the triangle in a flat encoded format
    # The triangle will be drawn manually by setting pixel data for its area
    pixels = bytearray([0] * (width * height))  # Initialize all pixels to white (index 0)

    # Draw a red triangle
    for y in range(200):
        for x in range(200):
            if (y >= 100) and (y <= 200 - (x // 2)) and (x <= 200):
                pixels[y * width + x] = 1  # Set pixel to red (index 1)
    
    # LZW encoded image data (simplified for this example, this is not the actual LZW compression)
    # Here we just simulate a single block of data for the triangle
    image_data = bytearray()
    for pixel in pixels:
        image_data.append(pixel)

    # Now we need to encode the image data length
    image_data_length = len(image_data).to_bytes(1, 'little')
    gif_header += image_data_length + image_data + b'\x00'  # End of image data

    # GIF Trailer
    gif_trailer = b'\x3B'  # GIF file terminator
    gif_header += gif_trailer

    # Output the GIF data to stdout
    print(gif_header)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # GIF signature/version
    width = 200
    height = 200

    # Logical Screen Descriptor
    logical_screen_descriptor = width.to_bytes(2, 'little') + \
                                height.to_bytes(2, 'little') + \
                                b'\xF7' +  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
                                b'\x00' +  # Background Color Index
                                b'\x00'    # Pixel Aspect Ratio (not used)

    # Global Color Table (white and red)
    # Color Table: White (255, 255, 255) and Red (255, 0, 0)
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'

    # Image Descriptor
    image_descriptor = b'\x2C' +  # Image Separator
                       b'\x00\x00' + b'\x00\x00' +  # Image Position (left, top)
                       width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + \
                       b'\x00'  # No local color table, no interlace, no sorted, no reserved

    # LZW Minimum Code Size
    lzw_minimum_code_size = b'\x08'  # LZW minimum code size

    # Image Data (LZW encoded)
    # To draw a triangle, we can use a very simple LZW encoding.
    # The triangle is defined in terms of pixels where the red pixels are defined.
    
    # The triangle vertices are at (100, 10), (10, 190), (190, 190)
    # Simplified representation in LZW:
    # The data array directly encodes the pixels, as a form of run-length encoding.
    image_data = bytearray()

    for y in range(height):
        for x in range(width):
            # Check if the pixel is within the triangle
            if (x >= 10 and x <= 190 and y >= 10 and y <= 190) and \
               (y <= (190 - x) + 100) and \
               (y <= (x - 10) + 190):
                image_data.append(1)  # Index for Red
            else:
                image_data.append(0)  # Index for White

    # LZW encoded data
    # Here we will use a simple RLE-like representation
    lzw_data = bytearray()
    count = 0
    last_value = image_data[0]

    for value in image_data:
        if value == last_value:
            count += 1
            if count == 255:
                lzw_data.append(count)
                lzw_data.append(last_value)
                count = 0
        else:
            if count > 0:
                lzw_data.append(count)
                lzw_data.append(last_value)
            count = 1
            last_value = value

    if count > 0:
        lzw_data.append(count)
        lzw_data.append(last_value)

    # End of Image Data
    lzw_data.append(0x00)  # End of the LZW data

    # Construct the final GIF file
    gif_file = gif_header + \
               logical_screen_descriptor + \
               global_color_table + \
               image_descriptor + \
               lzw_minimum_code_size + \
               lzw_data + \
               b'\x3B'  # Trailer

    # Write to stdout
    import sys
    sys.stdout.buffer.write(gif_file)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # GIF signature/version
    width = 200
    height = 200

    # Logical Screen Descriptor
    logical_screen_descriptor = width.to_bytes(2, 'little') + \
                                height.to_bytes(2, 'little') + \
                                b'\xF7' +  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
                                b'\x00' +  # Background Color Index
                                b'\x00'    # Pixel Aspect Ratio (not used)

    # Global Color Table (white and red)
    # Color Table: White (255, 255, 255) and Red (255, 0, 0)
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'

    # Image Descriptor
    image_descriptor = b'\x2C' +  # Image Separator
                       b'\x00\x00' + b'\x00\x00' +  # Image Position (left, top)
                       width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + \
                       b'\x00'  # No local color table, no interlace, no sorted, no reserved

    # LZW Minimum Code Size
    lzw_minimum_code_size = b'\x08'  # LZW minimum code size

    # Image Data (LZW encoded)
    # To draw a triangle, we can use a very simple LZW encoding.
    # The triangle is defined in terms of pixels where the red pixels are defined.
    
    # The triangle vertices are at (100, 10), (10, 190), (190, 190)
    # Simplified representation in LZW:
    # The data array directly encodes the pixels, as a form of run-length encoding.
    image_data = bytearray()

    for y in range(height):
        for x in range(width):
            # Check if the pixel is within the triangle
            if (x >= 10 and x <= 190 and y >= 10 and y <= 190) and \
               (y <= (190 - x) + 100) and \
               (y <= (x - 10) + 190):
                image_data.append(1)  # Index for Red
            else:
                image_data.append(0)  # Index for White

    # LZW encoded data
    # Here we will use a simple RLE-like representation
    lzw_data = bytearray()
    count = 0
    last_value = image_data[0]

    for value in image_data:
        if value == last_value:
            count += 1
            if count == 255:
                lzw_data.append(count)
                lzw_data.append(last_value)
                count = 0
        else:
            if count > 0:
                lzw_data.append(count)
                lzw_data.append(last_value)
            count = 1
            last_value = value

    if count > 0:
        lzw_data.append(count)
        lzw_data.append(last_value)

    # End of Image Data
    lzw_data.append(0x00)  # End of the LZW data

    # Construct the final GIF file
    gif_file = gif_header + \
               logical_screen_descriptor + \
               global_color_table + \
               image_descriptor + \
               lzw_minimum_code_size + \
               lzw_data + \
               b'\x3B'  # Trailer

    # Write to stdout
    import sys
    sys.stdout.buffer.write(gif_file)

if __name__ == "__main__":
    write_gif()

def write_gif():
    # GIF header
    gif_header = b'GIF89a'  # GIF signature/version
    width = 200
    height = 200

    # Logical Screen Descriptor
    logical_screen_descriptor = width.to_bytes(2, 'little') + \
                                height.to_bytes(2, 'little') + \
                                b'\xF7' +  # Global Color Table Flag, Color Resolution, Sort Flag, Size of Global Color Table
                                b'\x00' +  # Background Color Index
                                b'\x00'    # Pixel Aspect Ratio (not used)

    # Global Color Table (white and red)
    # Color Table: White (255, 255, 255) and Red (255, 0, 0)
    global_color_table = b'\xFF\xFF\xFF' + b'\xFF\x00\x00'

    # Image Descriptor
    image_descriptor = b'\x2C' +  # Image Separator
                       b'\x00\x00' + b'\x00\x00' +  # Image Position (left, top)
                       width.to_bytes(2, 'little') + height.to_bytes(2, 'little') + \
                       b'\x00'  # No local color table, no interlace, no sorted, no reserved

    # LZW Minimum Code Size
    lzw_minimum_code_size = b'\x08'  # LZW minimum code size

    # Image Data (LZW encoded)
    # To draw a triangle, we can use a very simple LZW encoding.
    # The triangle is defined in terms of pixels where the red pixels are defined.
    
    # The triangle vertices are at (100, 10), (10, 190), (190, 190)
    # Simplified representation in LZW:
    # The data array directly encodes the pixels, as a form of run-length encoding.
    image_data = bytearray()

    for y in range(height):
        for x in range(width):
            # Check if the pixel is within the triangle
            if (x >= 10 and x <= 190 and y >= 10 and y <= 190) and \
               (y <= (190 - x) + 100) and \
               (y <= (x - 10) + 190):
                image_data.append(1)  # Index for Red
            else:
                image_data.append(0)  # Index for White

    # LZW encoded data
    # Here we will use a simple RLE-like representation
    lzw_data = bytearray()
    count = 0
    last_value = image_data[0]

    for value in image_data:
        if value == last_value:
            count += 1
            if count == 255:
                lzw_data.append(count)
                lzw_data.append(last_value)
                count = 0
        else:
            if count > 0:
                lzw_data.append(count)
                lzw_data.append(last_value)
            count = 1
            last_value = value

    if count > 0:
        lzw_data.append(count)
        lzw_data.append(last_value)

    # End of Image Data
    lzw_data.append(0x00)  # End of the LZW data

    # Construct the final GIF file
    gif_file = gif_header + \
               logical_screen_descriptor + \
               global_color_table + \
               image_descriptor + \
               lzw_minimum_code_size + \
               lzw_data + \
               b'\x3B'  # Trailer

    # Write to stdout
    import sys
    sys.stdout.buffer.write(gif_file)

if __name__ == "__main__":
    write_gif()