| f | import sys | f | import sys | 
             |  |  |  | 
            | n | def read_input_data(): | n | def read_bmp_data(): | 
             |     return sys.stdin.buffer.read() |  |     return sys.stdin.buffer.read() | 
             |  |  |  | 
            | n | def validate_header(data): | n | def validate_bmp_header(data): | 
             |     if len(data) < 14: |  |     if len(data) < 14: | 
            | n |         return 'Invalid file size' | n |         return 'Incorrect size' | 
             |     if data[:2] != b'BM': |  |     if data[:2] != b'BM': | 
             |         return 'Not a Windows BMP' |  |         return 'Not a Windows BMP' | 
            | n |     total_size = int.from_bytes(data[2:6], 'little') | n |     file_size = int.from_bytes(data[2:6], 'little') | 
             |     if total_size != len(data): |  |     if file_size != len(data): | 
             |         return 'Incorrect size' |  |         return 'Incorrect size' | 
             |     if len(data) < 18: |  |     if len(data) < 18: | 
            | n |         return 'Incomplete BMP header' | n |         return 'Incorrect size' | 
             |     return total_size |  |     return file_size | 
             |  |  |  | 
            | n | def analyze_dib_header(data, start_offset): | n | def parse_dib_header(data, offset): | 
             |     dib_size = int.from_bytes(data[start_offset:start_offset + 4], 'litt |  |     header_size = int.from_bytes(data[offset:offset + 4], 'little') | 
             | le') |  |   | 
             |     valid_sizes = [12, 16, 40, 52, 56, 64, 108, 124] |  |     valid_sizes = [12, 16, 40, 52, 56, 64, 108, 124] | 
            | n |     if dib_size not in valid_sizes: | n |     if header_size not in valid_sizes: | 
             |         return ('Incorrect header size', None, None, None, None, None) |  |         return ('Incorrect header size', None, None, None, None, None) | 
            | n |     dib_end = start_offset + dib_size | n |     end_offset = offset + header_size | 
             |     if len(data) < dib_end: |  |     if len(data) < end_offset: | 
             |         return ('Incomplete DIB header', None, None, None, None, None) |  |         return ('Incorrect size', None, None, None, None, None) | 
             |     if dib_size == 12: |  |     if header_size == 12: | 
             |         img_width = int.from_bytes(data[start_offset + 4:start_offset +  |  |         width = int.from_bytes(data[offset + 4:offset + 6], 'little') | 
             | 6], 'little') |  |   | 
             |         img_height = int.from_bytes(data[start_offset + 6:start_offset + |  |         height = int.from_bytes(data[offset + 6:offset + 8], 'little') | 
             |  8], 'little') |  |   | 
             |         bpp = int.from_bytes(data[start_offset + 10:start_offset + 12],  |  |         bpp = int.from_bytes(data[offset + 10:offset + 12], 'little') | 
             | 'little') |  |   | 
             |         compression = 0 |  |         compression = 0 | 
            | n |         img_size = 0 | n |         image_size = 0 | 
             |     elif dib_size == 16: |  |     elif header_size == 16: | 
             |         img_width = int.from_bytes(data[start_offset + 4:start_offset +  |  |         width = int.from_bytes(data[offset + 4:offset + 6], 'little', si | 
             | 6], 'little', signed=True) |  | gned=True) | 
             |         img_height = int.from_bytes(data[start_offset + 6:start_offset + |  |         height = int.from_bytes(data[offset + 6:offset + 8], 'little', s | 
             |  8], 'little', signed=True) |  | igned=True) | 
             |         bpp = int.from_bytes(data[start_offset + 10:start_offset + 12],  |  |         bpp = int.from_bytes(data[offset + 10:offset + 12], 'little') | 
             | 'little') |  |   | 
             |         compression = int.from_bytes(data[start_offset + 12:start_offset |  |         compression = int.from_bytes(data[offset + 12:offset + 16], 'lit | 
             |  + 16], 'little') |  | tle') | 
             |         img_size = 0 |  |         image_size = 0 | 
             |     else: |  |     else: | 
            | n |         img_width = int.from_bytes(data[start_offset + 4:start_offset +  | n |         width = int.from_bytes(data[offset + 4:offset + 8], 'little', si | 
             | 8], 'little', signed=True) |  | gned=True) | 
             |         img_height = int.from_bytes(data[start_offset + 8:start_offset + |  |         height = int.from_bytes(data[offset + 8:offset + 12], 'little',  | 
             |  12], 'little', signed=True) |  | signed=True) | 
             |         bpp = int.from_bytes(data[start_offset + 14:start_offset + 16],  |  |         bpp = int.from_bytes(data[offset + 14:offset + 16], 'little') | 
             | 'little') |  |   | 
             |         compression = int.from_bytes(data[start_offset + 16:start_offset |  |         compression = int.from_bytes(data[offset + 16:offset + 20], 'lit | 
             |  + 20], 'little') |  | tle') | 
             |         img_size = int.from_bytes(data[start_offset + 20:start_offset +  |  |         image_size = int.from_bytes(data[offset + 20:offset + 24], 'litt | 
             | 24], 'little') |  | le') | 
             |     return (None, img_width, img_height, bpp, compression, img_size) |  |     return (None, width, height, bpp, compression, image_size) | 
             |  |  |  | 
            | n | def compute_image_size(width, height, bits_per_pixel): | n | def calculate_image_size(width, height, bpp): | 
             |     absolute_width = abs(width) |  |     abs_width = abs(width) | 
             |     absolute_height = abs(height) |  |     abs_height = abs(height) | 
             |     bits_in_row = absolute_width * bits_per_pixel |  |     bits_per_row = abs_width * bpp | 
             |     bytes_in_row = (bits_in_row + 7) // 8 |  |     bytes_per_row = (bits_per_row + 7) // 8 | 
             |     row_padding = (4 - bytes_in_row % 4) % 4 |  |     padding = (4 - bytes_per_row % 4) % 4 | 
             |     total_row_size = bytes_in_row + row_padding |  |     total_row_bytes = bytes_per_row + padding | 
             |     return (absolute_width, absolute_height, total_row_size * absolute_h |  |     return (abs_width, abs_height, total_row_bytes * abs_height) | 
             | eight) |  |   | 
             |  |  |  | 
            | n | def resolve_placeholder(img_size_actual, img_size_expected): | n | def determine_placeholder(actual_size, expected_size): | 
             |     if img_size_actual == img_size_expected + 2: |  |     if actual_size == expected_size + 2: | 
             |         return 2 |  |         return 2 | 
            | n |     if img_size_actual in {0, img_size_expected}: | n |     if actual_size in {0, expected_size}: | 
             |         return 0 |  |         return 0 | 
             |     return None |  |     return None | 
             | if __name__ == '__main__': |  | if __name__ == '__main__': | 
            | n |     bmp_content = read_input_data() | n |     bmp_data = read_bmp_data() | 
             |     header_validation = validate_header(bmp_content) |  |     file_validation = validate_bmp_header(bmp_data) | 
             |     if isinstance(header_validation, str): |  |     if isinstance(file_validation, str): | 
             |         print(header_validation) |  |         print(file_validation) | 
             |         sys.exit(0) |  |         sys.exit(0) | 
            | n |     err_msg, img_w, img_h, bpp, compress, img_size = analyze_dib_header( | n |     error, width, height, bits_per_pixel, compression_method, image_size | 
             | bmp_content, 14) |  |  = parse_dib_header(bmp_data, 14) | 
             |     if err_msg: |  |     if error: | 
             |         print(err_msg) |  |         print(error) | 
             |         sys.exit(0) |  |         sys.exit(0) | 
            | n |     width_abs, height_abs, computed_size = compute_image_size(img_w, img | n |     width_abs, height_abs, calculated_size = calculate_image_size(width, | 
             | _h, bpp) |  |  height, bits_per_pixel) | 
             |     placeholder_result = resolve_placeholder(img_size, computed_size) |  |     placeholder_size = determine_placeholder(image_size, calculated_size | 
             |   |  | ) | 
             |     if placeholder_result is None: |  |     if placeholder_size is None: | 
             |         print('Incorrect image size') |  |         print('Incorrect image size') | 
             |         sys.exit(0) |  |         sys.exit(0) | 
            | t |     print(f'{width_abs} {height_abs} {bpp} {compress} {placeholder_resul | t |     print(f'{width_abs} {height_abs} {bits_per_pixel} {compression_metho | 
             | t}') |  | d} {placeholder_size}') |