Tcl Library Source Code

# file to compile the magic file from magic(5) into a tcl program
package require fileutil              ; # File processing (input)
package require fileutil::magic::cgen ; # Code generator.
package require fileutil::magic::rt   ; # Runtime (typemap)
package require struct::list          ; # lrepeat.
package require struct::tree          ; #

package provide fileutil::magic::cfront 1.3.0

# ### ### ### ######### ######### #########
## Implementation

namespace eval ::fileutil::magic::cfront {
    # Configuration flag. (De)activate debugging output.
    # This is done during initialization.

	}
    }
    $tree set $node mod [dict keys $res]
}


proc ::fileutil::magic::cfront::parsetypenummod {tree node} {
    variable typemap
    # For numeric types, $mod is an operator and $mand is a number
    set line [$tree get $node line]
    set type [$tree get $node type]
    set cursor [$tree get $node cursor]
    if {[regexp -start $cursor {\A([-&|^+*/%=])} $line match mod]} {
	advance [string length $match]
	$tree set $node mod $mod
	# {to do} {parse floats?}
	set mand [parseint $tree $node] ; # mod operand
	if {[info exists typemap($type)]} {
	    lassign $typemap($type) dummy scan

	    # the modifier for a numeric type is a number of the same
	    # type
	    binary scan [binary format $scan $mand] $scan mand
	}
	$tree set $node mand $mand 
    } else {
	$tree set $node mod {}
	$tree set $node mand {}
    }
}


proc ::fileutil::magic::cfront::parsestringval {tree node} {
    variable floattestops
    variable inttestops

    variable floattestops
    variable inttestops
    variable stringtestops
    variable types_numeric_real
    variable types_numeric_all
    variable types_string
    variable types_verbatim
    variable typemap
    set type [$tree get $node type]
    if {$type in $types_verbatim} {
	parsetestverbatim $tree $node
	return
    }
    $tree set $node compinvert 0
    set testinvert 0

		}
		advance w1 char
	    } else {
		rewind 1
		break
	    }
	}
	set val [$parsecmd $tree $node]
	set scan [lindex $typemap([$tree get $node type]) 1]

	# get value in binary form, then back to numeric
	# this avoids problems with sign, as both values are
	# [binary scan]-converted identically
	binary scan [binary format $scan $val] $scan val
	$tree set $node val $val 
    } else {
	parseerror {don't know how to parse the test or this type}
    }
    switch $comp {
	= {
	    set comp ==
	}

# ### ### ### ######### ######### #########
## Requirements

package require Tcl 8.4
package require fileutil::magic::rt ; # Runtime core, for Access to the typemap
package require struct::list        ; # Our data structures.

package provide fileutil::magic::cgen 1.3.0

# ### ### ### ######### ######### #########
## Implementation

namespace eval ::fileutil::magic {
    namespace export *
}

    }
    lappend path [$tree index $node]
    $tree set $node path $path

    foreach name {type} {
	set $name [$tree get $node $name]
    }

    puts stderr [list frlaalm [$tree getall $node]]

    # Recursively creates and annotates a node for the specified
    # tests, and its sub-tests (args).


    # generate a proc call type for the type, Numeric or String
    variable ::fileutil::magic::rt::typemap

	    LessIndent

	    append result ${indent}<\n
	    LessIndent
	    append result ${indent}\}\n
	}
	T {
	    set desc [$tree get $node desc]
	    if {$desc ne {}} {
		append result "${indent}emit [list $desc]\n"
	    }
	    set o [GenerateOffset $tree $node]
	    set mod [$tree get $node mod]
	    append result "${indent}T $o [list $mod]\n"
	}
	Root {
	    foreach child [$tree children $node] {
		lappend result [treegen $tree $child]
		if {[lindex $result end] eq {}} {
		    set result [lreplace $result[set result {}] end end]
		}

		    # See ::fileutil::magic::rt::rtscan
		    if {$scan eq {me}} {
			set scan I
		    }

		    set val [$tree get $child val]










		    if {[info exists lastval] && $lastval != $val} {
			LessIndent
			append result "${indent}\}\n"
		    } 

		    if {![info exists lastval] || $lastval != $val} {
			append result "${indent}$val \{\n"

#
#####

# ### ### ### ######### ######### #########
## Requirements.

package require Tcl 8.6
package require fileutil::magic::rt 3-

# ### ### ### ######### ######### #########
## Implementation

namespace eval ::fileutil::magic::filetype {
    namespace import ::fileutil::magic::rt::*
}

	
		<
	}
	}}
	37
		{mach-o {U 37 mach-o-cpu [O 0]
	
	emit {\b:}
	T [O [I 8 ubelong 0 + 0 0]] {}
	
	if {[N belong [O 0] 0 0 {} {} x {}]} {
		>
			emit {\b]}
		<
	}
	}}

	}
	
	if {[N byte [O 2] 0 0 {} {} > 0]} {
		>
			emit {\b, split ROM}
		<
	}
	} sega-master-system-rom-header {switch [Nv byte [O 15] 0 & -16] {
		48 {
			>
				emit {Sega Master System}
				mime application/x-sms-rom
			<
		}
		64 {

	
	if {[N byte [O 0] 0 0 {} {} x {}]} {
		>
			emit {ROM image:}
		<
	}
	
	switch [Nv byte [O 14] 0 & -16] {
		-128 {
			>
				emit 8
			<
		}
		-112 {
			>
				emit 9
			<
		}
		-96 {
			>
				emit 10
			<
		}
		-80 {
			>
				emit 11
			<
		}
		-64 {
			>
				emit 12
			<
		}
		-48 {
			>
				emit 13
			<
		}
		-32 {
			>
				emit 14
			<
		}
		-16 {
			>
				emit 15
			<
		}
		0 {
			>
				if {[N leshort [O 12] 0 0 {} {} x {}]} {
					>
						emit %04x
					<
				}

			<
		}
		112 {
			>
				emit 7
			<
		}




	}

	



































	if {[N byte [O 14] 0 0 & -16 != 0]} {
		>
			if {[N leshort [O 12] 0 0 {} {} x {}]} {
				>
					emit {\b%04x}
				<
			}
	

	}
	} nintendo-3ds-version-code {if {[N leshort [O 0] 0 0 {} {} x {}]} {
		>
			emit {\b%u,}
		<
	}
	
	switch [Nv leshort [O 0] 0 & -1024] {
		0 {
			>
				emit 0
			<
		}
		1024 {
			>

				<
			}
	
		<
	}
	}}
	73
		{elf-mips {switch [Nv lelong [O 0] 0 & -268435456] {
		-2147483648 {
			>
				emit {MIPS64 rel2}
			<
		}
		-1879048192 {
			>
				emit {MIPS32 rel6}
			<
		}
		-1610612736 {
			>
				emit {MIPS64 rel6}
			<
		}
		0 {
			>
				emit MIPS-I
			<
		}
		268435456 {
			>

			<
		}
		1879048192 {
			>
				emit {MIPS32 rel2}
			<
		}















	}
	} elf-sparc {switch [Nv lelong [O 0] 0 & 16776960] {
		256 {
			>
				emit {V8+ Required,}
			<
		}

			>
				emit {core file,}
				mime application/x-coredump
			<
		}
	}
	
	if {[N byte [O 7] 0 0 {} {} == -54]} {
		>
			if {[N leshort [O 16] 0 0 {} {} == -511]} {
				>
					emit executable,
					mime application/x-executable
				<
			}
	
		<
	}
	
	if {[N leshort [O 16] 0 0 {} {} & -256]} {
		>
			emit processor-specific,
		<
	}
	
	if {[S clear [O 18] 0 {} {} x {}]} {
		>
		<
	}
	
	switch [Nv leshort [O 18] 0 {} {}] {
		-32233 {
			>
				emit {Ubicom IP2xxx (unofficial),}
			<
		}
		-31630 {
			>
				emit {OpenRISC (obsolete),}
			<
		}
		-28635 {
			>
				emit {Cygnus PowerPC (unofficial),}
			<
		}
		-28634 {
			>
				emit {Alpha (unofficial),}
			<
		}
		-28607 {
			>
				emit {Cygnus M32R (unofficial),}
			<
		}
		-28544 {
			>
				emit {Cygnus V850 (unofficial),}
			<
		}
		-23664 {
			>
				emit {IBM S/390 (obsolete),}
			<
		}
		-21561 {
			>
				emit {Old Xtensa (unofficial),}
			<
		}
		-21179 {
			>
				emit {xstormy16 (unofficial),}
			<
		}
		-17749 {
			>
				emit {Old MicroBlaze (unofficial),,}
			<
		}
		-16657 {
			>
				emit {Cygnus MN10300 (unofficial),}
			<
		}
		-8531 {
			>
				emit {Cygnus MN10200 (unofficial),}
			<
		}
		-4083 {
			>
				emit {Toshiba MeP (unofficial),}
			<
		}
		-336 {
			>
				emit {Renesas M32C (unofficial),}
			<
		}
		-326 {
			>
				emit {Vitesse IQ2000 (unofficial),}
			<
		}
		-325 {
			>
				emit {NIOS (unofficial),}
			<
		}
		-275 {
			>
				emit {Moxie (unofficial),}
			<
		}
		0 {
			>
				emit {no machine,}
			<
		}
		1 {
			>

			<
		}
		40 {
			>
				emit ARM,
				if {[N byte [O 4] 0 0 {} {} == 1]} {
					>
						switch [Nv lelong [O 36] 0 & -16777216] {
							67108864 {
								>
									emit EABI4
								<
							}
							83886080 {
								>

			<
		}
		30326 {
			>
				emit {Cygnus D30V (unofficial),}
			<
		}





















































































	}
	
	if {[D [O 18]]} {
		>
			if {[N leshort [O 18] 0 0 {} {} x {}]} {
				>
					emit {*unknown arch 0x%x*}

			}
	
		<
	}
	} partition-entry {if {[N ubyte [O 4] 0 0 {} {} > 0]} {
		>
			emit {\b; partition}
			if {[N leshort [O 64] 0 0 {} {} == -21931]} {
				>
					emit 1
				<
			}
	
			if {[N leshort [O 48] 0 0 {} {} == -21931]} {
				>
					emit 2
				<
			}
	
			if {[N leshort [O 32] 0 0 {} {} == -21931]} {
				>
					emit 3
				<
			}
	
			if {[N leshort [O 16] 0 0 {} {} == -21931]} {
				>
					emit 4
				<
			}
	
			if {[N ubyte [O 4] 0 0 {} {} x {}]} {
				>

			}
	
			mime application/x-iso9660-image
			ext iso/udf
		<
	}
	
	if {[N leshort [O 510] 0 0 {} {} == -21931]} {
		>
			emit {(DOS/MBR boot sector)}
		<
	}
	
	if {[S string [O 32808] 0 T {} > \0]} {
		>
			emit '%s'
		<
	}
	
	if {[S string [O 34816] 0 {} {} eq \000CD001\001EL\ TORITO\ SPECIFICATION]} {
		>
			emit (bootable)
		<
	}
	}}
	81
		{swf-details {if {[S string [O 0] 0 {} {} eq F]} {
		>
			if {[N byte [O 8] 0 0 & -3 == 8]} {
				>
					emit {Macromedia Flash data}
					if {[N byte [O 3] 0 0 {} {} x {}]} {
						>
							emit {\b, version %d}
						<
					}
	
					mime application/x-shockwave-flash
				<
			}
	
			if {[N byte [O 8] 0 0 & -2 == 16]} {
				>
					emit {Macromedia Flash data}
					if {[N byte [O 3] 0 0 {} {} x {}]} {
						>
							emit {\b, version %d}
						<
					}

						<
					}
	
					mime application/x-shockwave-flash
				<
			}
	
			if {[N beshort [O 8] 0 0 & -121 == 8192]} {
				>
					emit {Macromedia Flash data}
					if {[N byte [O 3] 0 0 {} {} x {}]} {
						>
							emit {\b, version %d}
						<
					}
	
					mime application/x-shockwave-flash
				<
			}
	
			if {[N beshort [O 8] 0 0 & -32 == 12288]} {
				>
					emit {Macromedia Flash data}
					if {[N byte [O 3] 0 0 {} {} x {}]} {
						>
							emit {\b, version %d}
						<
					}

	
			if {[S string [O 0] 0 {} {} x {}]} {
				>
					emit '%-.56s'
				<
			}
	
			emit {\b: }
			T [O [I 56 long 0 + 0 0]] {}
	
		<
	}
	}}
	98
		{gpt-mbr-type {if {[N ubyte [O 450] 0 0 {} {} == 238]} {
		>

		>
			emit {\b, direntries=%d}
		<
	}
	
	U 111 tiff_entry [O 2]
	} tiff_entry {switch [Nv leshort [O 0] 0 {} {}] {
		-32104 {
			>
				if {[S string [O [I 8 ulelong 0 + 0 0]] 0 {} {} x {}]} {
					>
						emit {\b, copyright=%s}
					<
				}
	
				U 111 tiff_entry [O 12]
	
			<
		}
		-30871 {
			>
				U 111 tiff_entry [O 12]
	
			<
		}
		-30683 {
			>
				emit {\b, GPS-Data}
				U 111 tiff_entry [O 12]
	
			<
		}
		254 {
			>
				U 111 tiff_entry [O 12]
	
			<
		}
		256 {

		}
		259 {
			>
				if {[N lelong [O 4] 0 0 {} {} == 1]} {
					>
						emit {\b, compression=}
						switch [Nv leshort [O 8] 0 {} {}] {























































							-32763 {
								>
									emit {\bPackBits (Macintosh RLE)}
								<
							}
							-32727 {
								>

									emit {\bJPEG2000}
								<
							}
							-30823 {
								>
									emit {\bNikon NEF Compressed}
								<
							}
							1 {
								>
									emit {\bnone}
								<
							}
							2 {
								>
									emit {\bhuffman}
								<
							}
							3 {
								>
									emit {\bbi-level group 3}
								<
							}
							4 {
								>
									emit {\bbi-level group 4}
								<
							}
							5 {
								>
									emit {\bLZW}
								<
							}
							6 {
								>
									emit {\bJPEG (old)}
								<
							}
							7 {
								>
									emit {\bJPEG}
								<
							}
							8 {
								>
									emit {\bdeflate}
								<
							}
							9 {
								>
									emit {\bJBIG, ITU-T T.85}
								<
							}
							10 {
								>
									emit {\bJBIG, ITU-T T.43}
								<
							}
							32766 {
								>
									emit {\bNeXT RLE 2-bit}
								<
							}
						}
	
						if {[D [O 8]]} {
							>
								if {[N leshort [O 8] 0 0 {} {} x {}]} {
									>

			>
				U 111 tiff_entry [O 12]
	
			<
		}
		532 {
			>

























				U 111 tiff_entry [O 12]
	
			<
		}
	}
	} png-ihdr {if {[N belong [O 0] 0 0 {} {} x {}]} {
		>

			<
		}
		-31 {
			>
				if {[S string [O 4] 0 {} {} eq Exif]} {
					>
						emit {\b, Exif Standard: [}
						T [O 10] r
	
						if {[S string [O 10] 0 {} {} x {}]} {
							>
								emit {\b]}
							<
						}
	

					<
				}
	
			<
		}
	}
	
	if {[N beshort [O 0] 0 0 & -32 == -32]} {
		>
			U 120 jpeg_segment [O [I 2 ubeshort 0 + 0 2]]
	
		<
	}
	
	if {[N beshort [O 0] 0 0 & -48 == -48]} {
		>
			if {[N beshort [O 0] 0 0 & -32 != -32]} {
				>
					U 120 jpeg_segment [O [I 2 ubeshort 0 + 0 2]]
	
				<
			}
	
		<

						emit {64-bit architecture=%d}
					<
				}
	
			<
		}
	}
	} mach-o-be {if {[N byte [O 0] 0 0 {} {} == -49]} {
		>
			emit 64-bit
		<
	}
	
	U 135 mach-o-cpu [O 4]
	

	
	if {[N byte [O 73] 0 0 {} {} & 64]} {
		>
			emit {\b, invisible}
		<
	}
	
	if {[N byte [O 73] 0 0 {} {} & -128]} {
		>
			emit {\b, locked}
		<
	}
	
	if {[N ubeshort [O 79] 0 0 {} {} != 0]} {
		>

			emit {"%s"}
		<
	}
	
	if {[N ubelong [O 83] 0 0 {} {} != 0]} {
		>
			emit {\b }
			T [O 128] {}
	
		<
	}
	
	if {[N ubelong [O 87] 0 0 {} {} != 0]} {
		>
			if {[N ubelong [O 83] 0 0 + 128 x {}]} {

					emit {%u bytes}
				<
			}
	
			if {[N ubequad [O [I 83 ubeshort 0 + 0 128]] 0 0 {} {} x {}]} {
				>
					emit {resource }
					T [R [O -8]] {}
	
				<
			}
	
		<
	}
	} apple-type {if {[S string [O 0] 0 {} {} eq 8BIM]} {

		>
			if {[N ubyte [O 10] 0 0 {} {} < 2]} {
				>
					if {[N ubyte [O 11] 0 0 {} {} < 2]} {
						>
							if {[N ubyte [O 12] 0 0 {} {} < 4]} {
								>
									if {[N lefloat [O 17] 0 0 {} {} > 9.999999747378752e-5]} {
										>
											emit {DIY-Thermocam raw data}
										<
									}
	
								<
							}

	
	if {[S string [O 6] 0 {} {} eq SFX\ of\ LHarc]} {
		>
			emit {\b, %s}
		<
	}
	
	if {[N leshort [O 510] 0 0 {} {} == -21931]} {
		>
			emit {\b, boot code}
		<
	}
	
	if {[S string [O 85] 0 {} {} eq UPX]} {
		>

		>
			emit {\b, %d colors}
		<
	}
	
	if {[N ubelong [O [I 12 ulelong 0 + 0 0]] 0 0 {} {} == 2303741511]} {
		>
			emit {\b with}
			T [R [O -4]] {}
	
		<
	}
	
	if {[N ubelong [O [I 12 ulelong 0 + 0 0]] 0 0 {} {} != 2303741511]} {
		>
		<

		<
	}
	}}
	199
		{pgp {switch [Nv byte [O 0] 0 {} {}] {
		48 {
			>
				switch [Nv byte [O 1] 0 & -64] {
					-128 {
						>
							emit {Sym. Encrypted and Integrity Protected Data}
						<
					}
					-64 {
						>
							emit {Modification Detection Code}
						<
					}
					0 {
						>
							emit {Unused [0%x]}
						<
					}
					64 {
						>
							emit {User Attribute}
						<
					}










				}
	
			<
		}
		103 {
			>
				emit {Reserved (old)}

		118 {
			>
				emit {Unused (old)}
			<
		}
		119 {
			>
				switch [Nv byte [O 1] 0 & -64] {










					-128 {
						>
							emit Signature
						<
					}
					-64 {
						>
							emit {Symmetric-Key Encrypted Session Key}
						<
					}
					0 {
						>
							emit Reserved
						<
					}
					64 {
						>
							emit {Public-Key Encrypted Session Key}
						<
					}
				}
	
			<
		}
		120 {
			>
				switch [Nv byte [O 1] 0 & -64] {










					-128 {
						>
							emit Public-Key
						<
					}
					-64 {
						>
							emit Secret-Subkey
						<
					}
					0 {
						>
							emit {One-Pass Signature}
						<
					}
					64 {
						>
							emit Secret-Key
						<
					}
				}
	
			<
		}
		121 {
			>
				switch [Nv byte [O 1] 0 & -64] {










					-128 {
						>
							emit Marker
						<
					}
					-64 {
						>
							emit {Literal Data}
						<
					}
					0 {
						>
							emit {Compressed Data}
						<
					}
					64 {
						>
							emit {Symmetrically Encrypted Data}
						<
					}
				}
	
			<
		}
		122 {
			>
				switch [Nv byte [O 1] 0 & -64] {










					-128 {
						>
							emit Public-Subkey
						<
					}
					-64 {
						>
							emit {Unused [z%x]}
						<
					}
					0 {
						>
							emit Trust
						<
					}
					64 {
						>
							emit {User ID}
						<
					}
				}
	
			<
		}
	}
	} crypto {switch [Nv byte [O 0] 0 {} {}] {

			U 214 riff-walk [R [O [I 4 ulelong 0 + 0 4]]]
	
		<
	}
	
	if {[S string [O 0] 0 {} {} eq VP8]} {
		>
			if {[N byte [O 11] 0 0 {} {} == -99]} {
				>
					if {[N byte [O 12] 0 0 {} {} == 1]} {
						>
							if {[N byte [O 13] 0 0 {} {} == 42]} {
								>
									emit {\b, VP8 encoding}
									if {[N leshort [O 14] 0 0 & 16383 x {}]} {
										>
											emit {\b, %d}
										<
									}
	
									if {[N leshort [O 16] 0 0 & 16383 x {}]} {
										>
											emit {\bx%d, Scaling:}
										<
									}
	
									switch [Nv leshort [O 14] 0 & -16384] {
										0 {
											>
												emit {\b [none]}
											<
											>
												emit {\bx[none]}
											<

											<
											>
												emit {\bx[2]}
											<
										}
									}
	
									switch [Nv byte [O 15] 0 & -128] {





										-128 {
											>
												emit {\b, bad color specification}
											<
										}
										0 {
											>
												emit {\b, YUV color}
											<
										}
									}
	
									switch [Nv byte [O 15] 0 & 64] {
										0 {
											>
												emit {\b, decoders should clamp}

	226
		{sereal {if {[N byte [O 4] 0 0 & 15 x {}]} {
		>
			emit {(version %d,}
		<
	}
	
	switch [Nv byte [O 4] 0 & -16] {
		0 {
			>
				emit uncompressed)
			<
		}
		16 {
			>
				emit {compressed with non-incremental Snappy)}
			<
		}
		32 {
			>
				emit {compressed with incremental Snappy)}
			<
		}
	}
	
	if {[N byte [O 4] 0 0 & -16 > 32]} {
		>
			emit {unknown subformat, flag: %d>>4)}
		<
	}
	}}
	235
		{pcap-be {if {[N beshort [O 4] 0 0 {} {} x {}]} {

	
	if {[N ubelong [O 132] 0 0 {} {} x {}]} {
		>
			emit {%u bytes }
		<
	}
	
	T [O [I 128 ubelong 0 + 0 0]] {}
	
	if {[N ubelong [O 136] 0 0 {} {} x {}]} {
		>
			emit {\b, at 0x%x}
		<
	}
	
	if {[N ubelong [O 140] 0 0 {} {} x {}]} {
		>
			emit {%u bytes }
		<
	}
	
	T [O [I 136 ubelong 0 + 0 0]] {}
	
	if {[N ubelong [O 144] 0 0 {} {} != 0]} {
		>
			emit {\b, at 0x%x}
			if {[N ubelong [O 148] 0 0 {} {} != 0]} {
				>
					emit {%u bytes}

		<
	}
	}}

}
proc analyze {} {
	switch [Nv leshort 0 0 {} {}] {
		-13230 {
			>
				emit {RLE image data,}
				if {[N leshort 6 0 0 {} {} x {}]} {
					>
						emit {%d x}
					<
				}
	
				if {[N leshort 8 0 0 {} {} x {}]} {
					>
						emit %d
					<
				}
	
				if {[N leshort 2 0 0 {} {} > 0]} {
					>
						emit {\b, lower left corner: %d}
					<
				}
	
				if {[N leshort 4 0 0 {} {} > 0]} {
					>
						emit {\b, lower right corner: %d}
					<
				}
	
				if {[N byte 10 0 0 & 1 == 1]} {
					>
						emit {\b, clear first}
					<
				}
	
				if {[N byte 10 0 0 & 2 == 2]} {
					>
						emit {\b, no background}
					<
				}
	
				if {[N byte 10 0 0 & 4 == 4]} {
					>
						emit {\b, alpha channel}
					<
				}
	
				if {[N byte 10 0 0 & 8 == 8]} {
					>
						emit {\b, comment}
					<
				}
	
				if {[N byte 11 0 0 {} {} > 0]} {
					>
						emit {\b, %d color channels}
					<
				}
	
				if {[N byte 12 0 0 {} {} > 0]} {
					>
						emit {\b, %d bits per pixel}
					<
				}
	
				if {[N byte 13 0 0 {} {} > 0]} {
					>
						emit {\b, %d color map channels}
					<
				}
	
			<
		}
		-5536 {
			>
				emit {ARJ archive data}
				mime application/x-arj
				if {[N byte 5 0 0 {} {} x {}]} {
					>
						emit {\b, v%d,}
					<
				}
	
				if {[N byte 8 0 0 {} {} & 4]} {
					>
						emit multi-volume,
					<
				}
	
				if {[N byte 8 0 0 {} {} & 16]} {
					>
						emit slash-switched,
					<
				}
	
				if {[N byte 8 0 0 {} {} & 32]} {
					>
						emit backup,
					<
				}
	
				if {[S string 34 0 {} {} x {}]} {
					>
						emit {original name: %s,}
					<
				}
	
				switch [Nv byte 7 0 {} {}] {
					0 {
						>
							emit {os: MS-DOS}
						<
					}
					1 {
						>
							emit {os: PRIMOS}
						<
					}
					2 {
						>
							emit {os: Unix}
						<
					}
					3 {
						>
							emit {os: Amiga}
						<
					}
					4 {
						>
							emit {os: Macintosh}
						<
					}
					5 {
						>
							emit {os: OS/2}
						<
					}
					6 {
						>
							emit {os: Apple ][ GS}
						<
					}
					7 {
						>
							emit {os: Atari ST}
						<
					}
					8 {
						>
							emit {os: NeXT}
						<
					}
					9 {
						>
							emit {os: VAX/VMS}
						<
					}
				}
	
				if {[N byte 3 0 0 {} {} > 0]} {
					>
						emit %d\]
					<
				}
	
			<
		}
		-5247 {
			>
				emit {PRCS packaged project}
			<
		}
		-155 {
			>
				emit {old 16-bit-int little-endian archive}
				if {[S string 2 0 {} {} eq __.SYMDEF]} {
					>
						emit {random library}
					<
				}
	
			<
			>
				emit x.out
				if {[S string 2 0 {} {} eq __.SYMDEF]} {
					>
						emit randomized
					<
				}
	
				if {[N byte 0 0 0 {} {} x {}]} {
					>
						emit archive
					<
				}
	
			<
		}
		-147 {
			>
				emit {very old 16-bit-int little-endian archive}
			<
		}
		257 {
			>
				if {[N ulelong 68 0 0 {} {} != 88]} {
					>
						emit {PDP-11 UNIX/RT ldp}
					<
				}

	
				if {[N leshort 30 0 0 {} {} & 8]} {
					>
						emit fixed-stack
					<
				}
	
				if {[N byte 28 0 0 {} {} & -128]} {
					>
						emit byte-swapped
					<
				}
	
				if {[N byte 28 0 0 {} {} & 64]} {
					>
						emit word-swapped
					<
				}
	
				if {[N lelong 16 0 0 {} {} > 0]} {
					>
						emit not-stripped
					<
				}
	
				if {[N leshort 30 0 0 {} {} ^ -16384]} {
					>
						emit pre-SysV
					<
				}
	
				if {[N leshort 30 0 0 {} {} & 16384]} {
					>
						emit V2.3
					<
				}
	
				if {[N leshort 30 0 0 {} {} & -32768]} {
					>
						emit V3.0
					<
				}
	
				if {[N byte 28 0 0 {} {} & 4]} {
					>

						}
	
					<
				}
	
			<
		}
	}
	
	switch [Nv beshort 0 0 {} {}] {
		-32768 {
			>
				if {[S string [I 2 ubeshort 0 - 0 2] 0 {} {} eq (c)CRI]} {
					>
						emit {CRI ADX ADPCM audio}
						if {[N byte 18 0 0 {} {} x {}]} {
							>
								emit v%u
							<
						}
	
						switch [Nv byte 4 0 {} {}] {
							2 {
								>
									emit {\b, pre-set prediction coefficients}
								<
							}
							3 {
								>
									emit {\b, standard ADX}
								<
							}
							4 {
								>
									emit {\b, exponential scale}
								<
							}
							5 {
								>
									emit {\b, AHX}
								<
							}
						}
	
						if {[N belong 8 0 0 {} {} x {}]} {
							>
								emit {\b, %u Hz}
							<
						}
	
						switch [Nv byte 18 0 {} {}] {
							3 {
								>
									if {[N beshort 2 0 0 {} {} > 43]} {
										>
											if {[N belong 24 0 0 {} {} != 0]} {
												>
													emit {\b, looping}
												<
											}
	
										<
									}
	
								<
							}
							4 {
								>
									if {[N beshort 2 0 0 {} {} > 55]} {
										>
											if {[N belong 36 0 0 {} {} != 0]} {
												>
													emit {\b, looping}
												<
											}
	
										<
									}
	
								<
							}
						}
	
						if {[N byte 19 0 0 & 8 == 8]} {
							>
								emit {\b, encrypted}
							<
						}
	
					<
				}
	
			<
			>
				emit {lif file}
			<
		}
		-32760 {
			>
				if {[S string 6 0 {} {} eq BS93]} {
					>
						emit {Lynx homebrew cartridge}
						if {[N beshort 2 0 0 {} {} x {}]} {
							>
								emit {\b, RAM start $%04x}
							<
						}
	
						mime application/x-atari-lynx-rom
					<
				}
	
				if {[S string 6 0 {} {} eq LYNX]} {
					>
						emit {Lynx cartridge}
						if {[N beshort 2 0 0 {} {} x {}]} {
							>
								emit {\b, RAM start $%04x}
							<
						}
	
						mime application/x-atari-lynx-rom
					<
				}
	
			<
		}
		-31486 {
			>
				emit {GPG encrypted data}
				mime {text/PGP # encoding: data}
			<
		}
		-30875 {
			>
				emit {disk quotas file}
			<
		}
		-30771 {
			>
				emit {OS9/6809 module:}
				switch [Nv byte 6 0 & 15] {
					0 {
						>
							emit non-executable
						<
					}
					1 {
						>
							emit {machine language}
						<
					}
					2 {
						>
							emit {BASIC I-code}
						<
					}
					3 {
						>
							emit {Pascal P-code}
						<
					}
					4 {
						>
							emit {C I-code}
						<
					}
					5 {
						>
							emit {COBOL I-code}
						<
					}
					6 {
						>
							emit {Fortran I-code}
						<
					}
				}
	
				switch [Nv byte 6 0 & -16] {
					-64 {
						>
							emit {system module}
						<
					}
					-48 {
						>
							emit {file manager}
						<
					}
					-32 {
						>
							emit {device driver}
						<
					}
					-16 {
						>
							emit {device descriptor}
						<
					}
					16 {
						>
							emit {program executable}
						<
					}
					32 {
						>
							emit subroutine
						<
					}
					48 {
						>
							emit multi-module
						<
					}
					64 {
						>
							emit {data module}
						<
					}
				}
	
			<
		}
		-27392 {
			>
				emit {PGP key security ring}
				mime application/x-pgp-keyring
			<
		}
		-27391 {
			>
				emit {PGP key security ring}
				mime application/x-pgp-keyring
			<
		}
		-26110 {
			>
				emit {Zebra Metafile graphic}
				switch [Nv leshort 2 0 {} {}] {
					1 {
						>
							emit {(version 1.x)}
						<
					}
					2 {
						>
							emit {(version 1.1x or 1.2x)}
						<
					}
					3 {
						>
							emit {(version 1.49)}
						<
					}
					4 {
						>
							emit {(version 1.50)}
						<
					}
				}
	
				if {[S string 4 0 {} {} x {}]} {
					>
						emit {(comment = %s)}
					<
				}
	
			<
		}
		-23040 {
			>
				emit {PGP encrypted data}
				mime {text/PGP # encoding: armored data}
			<
		}
		-21928 {
			>
				emit {floppy image data (IBM SaveDskF, old)}
			<
		}
		-21927 {
			>
				emit {floppy image data (IBM SaveDskF)}
			<
		}
		-21926 {
			>
				emit {floppy image data (IBM SaveDskF, compressed)}

			<
		}
		-21267 {
			>
				emit {Java serialization data}
				if {[N beshort 2 0 0 {} {} > 4]} {
					>
						emit {\b, version %d}
					<
				}
	
			<
		}
		-8185 {
			>
				emit {amd 29k coff archive}
			<
		}
		-7408 {
			>
				emit {Amiga Workbench}
				if {[N beshort 2 0 0 {} {} == 1]} {
					>
						switch [Nv byte 48 0 {} {}] {
							1 {
								>
									emit {disk icon}
								<
							}
							2 {
								>
									emit {drawer icon}
								<
							}
							3 {
								>
									emit {tool icon}
								<
							}
							4 {
								>
									emit {project icon}
								<
							}
							5 {
								>
									emit {garbage icon}
								<
							}
							6 {
								>
									emit {device icon}
								<
							}
							7 {
								>
									emit {kickstart icon}
								<
							}
							8 {
								>
									emit {workbench application icon}
								<
							}
						}
	
					<
				}
	
				if {[N beshort 2 0 0 {} {} > 1]} {
					>
						emit {icon, vers. %d}
					<
				}
	
			<
		}
		-1279 {
			>
				emit {QDOS object}
				if {[S pstring 2 0 {} {} x {}]} {
					>
						emit '%s'
					<
				}
	
			<
		}
		-511 {
			>
				emit {MySQL table definition file}
				if {[N byte 2 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
				switch [Nv byte 3 0 {} {}] {
					0 {
						>
							emit {\b, type UNKNOWN}
						<
					}
					1 {
						>
							emit {\b, type DIAM_ISAM}
						<
					}
					2 {
						>
							emit {\b, type HASH}
						<
					}
					3 {
						>
							emit {\b, type MISAM}
						<
					}
					4 {
						>
							emit {\b, type PISAM}
						<
					}
					5 {
						>
							emit {\b, type RMS_ISAM}
						<
					}
					6 {
						>
							emit {\b, type HEAP}
						<
					}
					7 {
						>
							emit {\b, type ISAM}
						<
					}
					8 {
						>
							emit {\b, type MRG_ISAM}
						<
					}
					9 {
						>
							emit {\b, type MYISAM}
						<
					}
					10 {
						>
							emit {\b, type MRG_MYISAM}
						<
					}
					11 {
						>
							emit {\b, type BERKELEY_DB}
						<
					}
					12 {
						>
							emit {\b, type INNODB}
						<
					}
					13 {
						>
							emit {\b, type GEMINI}
						<
					}
					14 {
						>
							emit {\b, type NDBCLUSTER}
						<
					}
					15 {
						>
							emit {\b, type EXAMPLE_DB}
						<
					}
					16 {
						>
							emit {\b, type CSV_DB}
						<
					}
					17 {
						>
							emit {\b, type FEDERATED_DB}
						<
					}
					18 {
						>
							emit {\b, type BLACKHOLE_DB}
						<
					}
					19 {
						>
							emit {\b, type PARTITION_DB}
						<
					}
					20 {
						>
							emit {\b, type BINLOG}
						<
					}
					21 {
						>
							emit {\b, type SOLID}
						<
					}
					22 {
						>
							emit {\b, type PBXT}
						<
					}
					23 {
						>
							emit {\b, type TABLE_FUNCTION}
						<
					}
					24 {
						>
							emit {\b, type MEMCACHE}
						<
					}
					25 {
						>
							emit {\b, type FALCON}
						<
					}
					26 {
						>
							emit {\b, type MARIA}
						<
					}
					27 {
						>
							emit {\b, type PERFORMANCE_SCHEMA}
						<
					}
					127 {
						>
							emit {\b, type DEFAULT}
						<
					}
				}
	
				if {[N ulong 51 0 0 {} {} x {}]} {
					>
						emit {\b, MySQL version %d}
					<
				}
	
			<
		}
		-508 {
			>
				emit {structured file}
			<
		}
		-155 {
			>
				emit {old 16-bit-int big-endian archive}
				if {[S string 2 0 {} {} eq __.SYMDEF]} {
					>
						emit {random library}
					<
				}
	















			<
		}
		-147 {
			>
				emit {very old 16-bit-int big-endian archive}
			<
		}
		-40 {
			>
				emit {JPEG image data}
				mime image/jpeg
				ext jpeg/jpg/jpe/jfif
				if {[S string 6 0 {} {} eq JFIF]} {
					>
						emit {\b, JFIF standard}
						if {[N byte 11 0 0 {} {} x {}]} {
							>
								emit {\b %d.}
							<
						}
	
						if {[N byte 12 0 0 {} {} x {}]} {
							>
								emit {\b%02d}
							<
						}
	
						switch [Nv byte 13 0 {} {}] {
							0 {
								>
									emit {\b, aspect ratio}
								<
							}
							1 {
								>
									emit {\b, resolution (DPI)}
								<
							}
							2 {
								>
									emit {\b, resolution (DPCM)}
								<
							}
						}
	
						if {[N beshort 14 0 0 {} {} x {}]} {
							>
								emit {\b, density %dx}
							<
						}
	
						if {[N beshort 16 0 0 {} {} x {}]} {
							>
								emit {\b%d}
							<
						}
	
						if {[N beshort 4 0 0 {} {} x {}]} {
							>
								emit {\b, segment length %d}
							<
						}
	
						if {[N byte 18 0 0 {} {} != 0]} {
							>
								emit {\b, thumbnail %dx}
								if {[N byte 19 0 0 {} {} x {}]} {
									>
										emit {\b%d}
									<
								}
	
							<
						}
	
					<
				}
	
				if {[S string 6 0 {} {} eq Exif]} {
					>
						emit {\b, Exif standard: [}
						T 12 r
	
						if {[S string 12 0 {} {} x {}]} {
							>
								emit {\b]}
							<
						}
	
					<
				}
	
				U 120 jpeg_segment [I 4 ubeshort 0 + 0 4]
	
			<
		}
		1 {
			>
				switch [Nv beshort 2 0 {} {}] {
					8 {
						>
							U 111 gem_info 0
	

				}
	
			<
		}
		2057 {
			>
				emit {Bentley/Intergraph MicroStation}
				if {[N byte 2 0 0 {} {} == -2]} {
					>
						if {[N beshort 4 0 0 {} {} == 6144]} {
							>
								emit {CIT raster CAD}
							<
						}
	
					<
				}
	
			<
		}
		2935 {
			>
				emit {ATSC A/52 aka AC-3 aka Dolby Digital stream,}
				mime audio/vnd.dolby.dd-raw
				switch [Nv byte 4 0 & -64] {
					-128 {
						>
							emit {32 kHz,}
						<
					}
					-64 {
						>
							emit {reserved frequency,}
						<
					}
					0 {
						>
							emit {48 kHz,}
						<
					}
					64 {
						>
							emit {44.1 kHz,}
						<
					}










				}
	
				switch [Nv byte 5 0 & 7] {
					0 {
						>
							emit {\b, complete main (CM)}
						<

	
				if {[N beshort 5 0 0 & 2016 > 1824]} {
					>
						emit {\b, karaoke}
					<
				}
	
				switch [Nv byte 6 0 & -32] {
					-128 {
						>
							emit {2 front/1 rear,}
							if {[N byte 6 0 0 & 4 == 4]} {
								>
									emit {LFE on,}
								<
							}
	
						<
					}
					-96 {
						>
							emit {3 front/1 rear,}
							if {[N byte 6 0 0 & 1 == 1]} {
								>
									emit {LFE on,}
								<
							}
	
						<
					}
					-64 {
						>
							emit {2 front/2 rear,}
							if {[N byte 6 0 0 & 4 == 4]} {
								>
									emit {LFE on,}
								<
							}
	
						<
					}
					-32 {
						>
							emit {3 front/2 rear,}
							if {[N byte 6 0 0 & 1 == 1]} {
								>
									emit {LFE on,}
								<
							}
	
						<
					}
					0 {
						>
							emit {1+1 front,}
							if {[N byte 6 0 0 & 16 == 16]} {
								>
									emit {LFE on,}
								<

						<
					}
					96 {
						>
							emit {3 front/0 rear,}
							if {[N byte 6 0 0 & 4 == 4]} {
								>












































									emit {LFE on,}
								<
							}
	
						<
					}
				}

				}
	
			<
		}
		19196 {
			>
				emit {OS9/68K module:}
				if {[N byte 20 0 0 & -128 == -128]} {
					>
						emit re-entrant
					<
				}
	
				if {[N byte 20 0 0 & 64 == 64]} {
					>

				}
	
			<
		}
		32639 {
			>
				emit {RDI Acoustic Doppler Current Profiler (ADCP)}


































































































































































































































































































































































































































































































































































































































































			<
		}
	}
	
	if {[N ubyte 0 0 0 {} {} > 0]} {
		>
			if {[N ubyte 0 0 0 {} {} < 9]} {
				>
					if {[N belong 16 0 0 & -33492752 == 12336]} {
						>
							if {[N ubyte 0 0 0 {} {} < 10]} {
								>
									if {[N ubeshort 2 0 0 {} {} x {}]} {
										>
											if {[S regex 18 0 {} {} eq \[0-9\]\[0-9\]\[0-9\]\[0-9\]\[0-9\]\[0-9\]]} {
												>

				<
			}
	
		<
	}
	
	switch [Nv belong 0 0 {} {}] {
		-2147479551 {
			>
				emit {AmigaOS outline tag}
			<
		}
		-2017063670 {
			>
				emit {python 2.0 byte-compiled}
			<
		}
		-1991489968 {
			>
				if {[N belong 4 0 0 {} {} == 218765834]} {
					>
					<
				}
	
				if {[N belong 12 0 0 {} {} == 0]} {
					>
						emit {Lytro Light Field Picture}
					<
				}
	
				if {[N belong 8 0 0 {} {} x {}]} {
					>
						emit {\b, version %d}
					<
				}
	
			<
		}
		-1728153892 {
			>
				if {[N ubeshort 4 0 0 {} {} < 10]} {
					>
						emit {APT cache data, version %u}
						if {[N ubeshort 6 0 0 {} {} x {}]} {
							>
								emit {\b.%u, 32 bit big-endian}
							<
						}
	
						U 15 apt-cache-32bit-be 0
	
					<
				}
	
				if {[N ubyte 4 0 0 {} {} > 9]} {
					>
						emit {APT cache data, version %u}
						if {[N ubyte 5 0 0 {} {} x {}]} {
							>
								emit {\b.%u, big-endian}
							<
						}
	
						U 15 apt-cache-be 0
	
					<
				}
	
			<
		}
		-1722938102 {
			>
				emit {python 1.5/1.6 byte-compiled}
			<
		}
		-1643377398 {
			>
				emit {python 3.3 byte-compiled}
			<
		}
		-1374734174 {
			>
				if {[N belong 12 0 0 {} {} == 1048576]} {
					>
						if {[N belong [I 8 ubelong 0 + 0 28] 0 0 {} {} == -1036804291]} {
							>
								emit {Nintendo GameCube embedded disc image:}
								U 51 nintendo-gcn-disc-common [I 8 ubelong 0 + 0 0]
	
								mime application/x-gamecube-rom
							<
						}
	
					<
				}
	
			<
		}
		-1275982582 {
			>
				emit {python 2.5 byte-compiled}
			<
		}
		-1195374706 {
			>
				emit {Linux kernel}
				if {[S string 483 0 {} {} eq Loading]} {
					>
						emit {version 1.3.79 or older}
					<
				}
	
				if {[S string 489 0 {} {} eq Loading]} {
					>
						emit {from prehistoric times}
					<
				}
	
			<
			>
				emit Linux
				if {[N belong 486 0 0 {} {} == 1162627923]} {
					>
						emit {ELKS Kernel}
					<
				}
	
				if {[N belong 486 0 0 {} {} != 1162627923]} {
					>
						emit {style boot sector}
					<
				}
	
			<
		}
		-1161903941 {
			>
				emit {IRIX N32 core dump}
				if {[N belong 4 0 0 {} {} == 1]} {
					>
						emit of
					<
				}
	
				if {[S string 16 0 {} {} > \0]} {
					>
						emit '%s'
					<
				}
	
			<
		}
		-1059131379 {
			>
				emit {GStreamer binary registry}
				if {[S string 4 0 {} {} x {}]} {
					>
						emit {\b, version %s}
					<
				}
	
			<
		}
		-1040441407 {
			>
				emit {Common Trace Format (CTF) trace data (BE)}
			<
		}
		-976170042 {
			>
				emit {DOS EPS Binary File}
				mime image/x-eps
				if {[N long 4 0 0 {} {} > 0]} {
					>
						emit {Postscript starts at byte %d}
						if {[N long 8 0 0 {} {} > 0]} {
							>
								emit {length %d}
								if {[N long 12 0 0 {} {} > 0]} {
									>
										emit {Metafile starts at byte %d}
										if {[N long 16 0 0 {} {} > 0]} {
											>
												emit {length %d}
											<
										}
	
									<
								}
	
								if {[N long 20 0 0 {} {} > 0]} {
									>
										emit {TIFF starts at byte %d}
										if {[N long 24 0 0 {} {} > 0]} {
											>
												emit {length %d}
											<
										}
	
									<
								}
	
							<
						}
	
					<
				}
	
			<
			>
				emit {DOS EPS Binary File}
				if {[N long 4 0 0 {} {} > 0]} {
					>
						emit {Postscript starts at byte %d}
						if {[N long 8 0 0 {} {} > 0]} {
							>
								emit {length %d}
								if {[N long 12 0 0 {} {} > 0]} {
									>
										emit {Metafile starts at byte %d}
										if {[N long 16 0 0 {} {} > 0]} {
											>
												emit {length %d}
											<
										}
	
									<
								}
	
								if {[N long 20 0 0 {} {} > 0]} {
									>
										emit {TIFF starts at byte %d}
										if {[N long 24 0 0 {} {} > 0]} {
											>
												emit {length %d}
											<
										}
	
									<
								}
	
							<
						}
	
					<
				}
	
			<
		}
		-951729837 {
			>
				emit GEOS
				switch [Nv byte 40 0 {} {}] {
					1 {
						>
							emit executable
						<
					}
					2 {
						>
							emit VMFile
						<
					}
					3 {
						>
							emit binary
						<
					}
					4 {
						>
							emit {directory label}
						<
					}
				}
	
				if {[N byte 40 0 0 {} {} < 1]} {
					>
						emit unknown
					<
				}
	
				if {[N byte 40 0 0 {} {} > 4]} {
					>
						emit unknown
					<
				}
	
				if {[S string 4 0 {} {} > \0]} {
					>
						emit {\b, name "%s"}
					<
				}
	
			<
		}
		-938869246 {
			>
				emit {Bentley/Intergraph MicroStation DGN vector CAD}
			<
		}
		-889275714 {
			>
				if {[N belong 4 0 0 {} {} > 30]} {
					>
						emit {compiled Java class data,}
						if {[N beshort 6 0 0 {} {} x {}]} {
							>
								emit {version %d.}
							<
						}
	
						if {[N beshort 4 0 0 {} {} x {}]} {
							>
								emit {\b%d}
							<
						}
	
						switch [Nv belong 4 0 {} {}] {
							46 {
								>
									emit {(Java 1.2)}
								<
							}
							47 {
								>
									emit {(Java 1.3)}
								<
							}
							48 {
								>
									emit {(Java 1.4)}
								<
							}
							49 {
								>
									emit {(Java 1.5)}
								<
							}
							50 {
								>
									emit {(Java 1.6)}
								<
							}
							51 {
								>
									emit {(Java 1.7)}
								<
							}
							52 {
								>
									emit {(Java 1.8)}
								<
							}
						}
	
						mime application/x-java-applet
					<
				}
	
			<
			>
				if {[N belong 4 0 0 {} {} == 1]} {
					>
						emit {Mach-O universal binary with 1 architecture:}
						U 37 mach-o 8
	
						mime application/x-mach-binary
					<
				}
	
				if {[N belong 4 0 0 {} {} > 1]} {
					>
						if {[N belong 4 0 0 {} {} < 20]} {
							>
								emit {Mach-O universal binary with %d architectures:}
								U 37 mach-o 8
	
								mime application/x-mach-binary
							<
						}
	
						switch [Nv belong 4 0 {} {}] {
							2 {
								>
									U 37 mach-o 28
	
								<
							}
							3 {
								>
									U 37 mach-o 48
	
								<
							}
							4 {
								>
									U 37 mach-o 68
	
								<
							}
							5 {
								>
									U 37 mach-o 88
	
								<
							}
							6 {
								>
									U 37 mach-o 108
	
								<
							}
						}
	
					<
				}
	
			<
		}
		-889270259 {
			>
				emit {JAR compressed with pack200,}
				if {[N byte 5 0 0 {} {} x {}]} {
					>
						emit {version %d.}
					<
				}
	
				if {[N byte 4 0 0 {} {} x {}]} {
					>
						emit {\b%d}
						mime application/x-java-pack200
					<
				}
	
			<
			>
				emit {JAR compressed with pack200,}
				if {[N byte 5 0 0 {} {} x {}]} {
					>
						emit {version %d.}
					<
				}
	
				if {[N byte 4 0 0 {} {} x {}]} {
					>
						emit {\b%d}
						mime application/x-java-pack200
					<
				}
	
			<
		}
		-825307442 {
			>
				emit {Java JCE KeyStore}
				mime application/x-java-jce-keystore
			<
		}
		-804389139 {
			>
				if {[N byte [R [I 8 ubelong 0 + 0 0]] 0 0 {} {} x {}]} {
					>
						if {[N byte [R [I 12 ubelong 0 + 0 0]] 0 0 {} {} x {}]} {
							>
								if {[N belong 20 0 0 {} {} > 1]} {
									>
										emit {Device Tree Blob version %d}
										if {[N belong 4 0 0 {} {} x {}]} {
											>
												emit {\b, size=%d}
											<
										}
	
										if {[N belong 20 0 0 {} {} > 1]} {
											>
												if {[N belong 28 0 0 {} {} x {}]} {
													>
														emit {\b, boot CPU=%d}
													<
												}
	
											<
										}
	
										if {[N belong 20 0 0 {} {} > 2]} {
											>
												if {[N belong 32 0 0 {} {} x {}]} {
													>
														emit {\b, string block size=%d}
													<
												}
	
											<
										}
	
										if {[N belong 20 0 0 {} {} > 16]} {
											>
												if {[N belong 36 0 0 {} {} x {}]} {
													>
														emit {\b, DT structure block size=%d}
													<
												}
	
											<
										}
	
									<
								}
	
							<
						}
	
					<
				}
	
			<
		}
		-772666102 {
			>
				emit {python 2.6 byte-compiled}
			<
		}
		-559043264 {
			>
				emit {IRIX 64-bit core dump}
				if {[N belong 4 0 0 {} {} == 1]} {
					>
						emit of
					<
				}
	
				if {[S string 16 0 {} {} > \0]} {
					>
						emit '%s'
					<
				}
	
			<
		}
		-559043152 {
			>
				emit {IRIX core dump}
				if {[N belong 4 0 0 {} {} == 1]} {
					>
						emit of
					<
				}
	
				if {[S string 16 0 {} {} > \0]} {
					>
						emit '%s'
					<
				}
	
			<
		}
		-559039810 {
			>
				emit {IRIX Parallel Arena}
				if {[N belong 8 0 0 {} {} > 0]} {
					>
						emit {- version %d}
					<
				}
	
			<
		}
		-364936773 {
			>
				emit {Conary changeset data}
			<
		}
		-307499301 {
			>
				emit RPM
				mime application/x-rpm
				if {[N byte 4 0 0 {} {} x {}]} {
					>
						emit v%d
					<
				}
	
				if {[N byte 5 0 0 {} {} x {}]} {
					>
						emit {\b.%d}
					<
				}
	
				switch [Nv beshort 6 0 {} {}] {
					0 {
						>
							emit bin
							switch [Nv beshort 8 0 {} {}] {
								1 {
									>
										emit i386/x86_64
									<
								}
								2 {
									>
										emit Alpha/Sparc64
									<
								}
								3 {
									>
										emit Sparc
									<
								}
								4 {
									>
										emit MIPS
									<
								}
								5 {
									>
										emit PowerPC
									<
								}
								6 {
									>
										emit 68000
									<
								}
								7 {
									>
										emit SGI
									<
								}
								8 {
									>
										emit RS6000
									<
								}
								9 {
									>
										emit IA64
									<
								}
								10 {
									>
										emit Sparc64
									<
								}
								11 {
									>
										emit MIPSel
									<
								}
								12 {
									>
										emit ARM
									<
								}
								13 {
									>
										emit MiNT
									<
								}
								14 {
									>
										emit S/390
									<
								}
								15 {
									>
										emit S/390x
									<
								}
								16 {
									>
										emit PowerPC64
									<
								}
								17 {
									>
										emit SuperH
									<
								}
								18 {
									>
										emit Xtensa
									<
								}
								255 {
									>
										emit noarch
									<
								}
							}
	
						<
					}
					1 {
						>
							emit src
						<
					}
				}
	
			<
		}
		-302060034 {
			>
				emit {Sun 'jks' Java Keystore File data}
			<
		}
		-301200118 {
			>
				emit {python 3.4 byte-compiled}
			<
		}
		-249691108 {
			>
				emit {magic binary file for file(1) cmd}
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {(version %d) (big endian)}
					<
				}
	
			<
		}
		-86111232 {
			>
				emit {Mac OS X Code Requirement}
				if {[N belong 8 0 0 {} {} == 1]} {
					>
						emit (opExpr)
					<
				}
	
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {- %d bytes}
					<
				}
	
			<
		}
		-86111231 {
			>
				emit {Mac OS X Code Requirement Set}
				if {[N belong 8 0 0 {} {} > 1]} {
					>
						emit {containing %d items}
					<
				}
	
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {- %d bytes}
					<
				}
	
			<
		}
		-86111230 {
			>
				emit {Mac OS X Code Directory}
				if {[N belong 8 0 0 {} {} x {}]} {
					>
						emit {version %x}
					<
				}
	
				if {[N belong 12 0 0 {} {} > 0]} {
					>
						emit {flags 0x%x}
					<
				}
	
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {- %d bytes}
					<
				}
	
			<
		}
		-86111040 {
			>
				emit {Mac OS X Detached Code Signature (non-executable)}
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {- %d bytes}
					<
				}
	
			<
		}
		-86111039 {
			>
				emit {Mac OS X Detached Code Signature}
				if {[N belong 8 0 0 {} {} > 1]} {
					>
						emit {(%d elements)}
					<
				}
	
				if {[N belong 4 0 0 {} {} x {}]} {
					>
						emit {- %d bytes}
					<
				}
	
			<
		}
		-17957139 {
			>
				emit {Java KeyStore}
				mime application/x-java-keystore
			<
		}
		-12432129 {
			>
				emit {WRAptor packer (c64)}
			<
		}
		-12169394 {
			>
				emit {DOS code page font data collection}
			<
		}
		-11534511 {
			>
				emit {JPEG 2000 codestream}
			<
		}
		-65536 {
			>
				if {[N belong 24 0 0 {} {} == 0]} {
					>
						if {[N belong 28 0 0 {} {} == 0]} {
							>
								if {[N belong 32792 0 0 {} {} == 1562156707]} {
									>
										emit {Nintendo Wii SDK disc image:}
										U 51 nintendo-gcn-disc-common 32768
	
									<
								}
	
								if {[N belong 32796 0 0 {} {} == -1036804291]} {
									>
										emit {Nintendo GameCube SDK disc image:}
										U 51 nintendo-gcn-disc-common 32768
	
									<
								}
	
							<
						}
	
					<
				}
	
			<
		}
		1 {
			>
				if {[N byte 4 0 0 & 31 == 7]} {
					>
						emit {JVT NAL sequence, H.264 video}
						switch [Nv byte 5 0 {} {}] {
							66 {

	
				if {[N belong 88 0 0 {} {} & 8]} {
					>
						emit POSIX
					<
				}
	
				if {[N belong 84 0 0 {} {} & -2147483648]} {
					>
						emit executable
					<
				}
	
				if {[N belong 84 0 0 {} {} & 1073741824]} {
					>

	
				if {[N beshort 6 0 0 {} {} > 0]} {
					>
						emit {- highwater %d}
					<
				}
	
				if {[N belong 8 0 0 {} {} & -2147483648]} {
					>
						emit {save fp regs}
					<
				}
	
				if {[N belong 8 0 0 {} {} & 536870912]} {
					>

				emit {HP s200 executable}
				if {[N beshort 4 0 0 {} {} > 0]} {
					>
						emit {- version %d}
					<
				}
	
				if {[N belong 8 0 0 {} {} & -2147483648]} {
					>
						emit {save fp regs}
					<
				}
	
				if {[N belong 8 0 0 {} {} & 1073741824]} {
					>

				emit {HP s200 pure executable}
				if {[N beshort 4 0 0 {} {} > 0]} {
					>
						emit {- version %d}
					<
				}
	
				if {[N belong 8 0 0 {} {} & -2147483648]} {
					>
						emit {save fp regs}
					<
				}
	
				if {[N belong 8 0 0 {} {} & 1073741824]} {
					>

				emit {HP s200 demand-load executable}
				if {[N beshort 4 0 0 {} {} > 0]} {
					>
						emit {- version %d}
					<
				}
	
				if {[N belong 8 0 0 {} {} & -2147483648]} {
					>
						emit {save fp regs}
					<
				}
	
				if {[N belong 8 0 0 {} {} & 1073741824]} {
					>

	
				if {[N byte 36 0 0 {} {} x {}]} {
					>
						emit {\b.%d}
					<
				}
	




















































































































































































































































































































































































































































































































































































































































































































































































































































































			<
		}
	}
	
	if {[S search 0 0 {} 8192 eq (input,]} {
		>
			emit {Algol 68 source text}

		>
			emit {Algol 68 source text}
			mime text/x-Algol68
		<
	}
	
	switch [Nv short 0 0 {} {}] {
		-21846 {
			>
				emit {SoftQuad DESC or font file binary}
				if {[N short 2 0 0 {} {} > 0]} {
					>
						emit {- version %d}
					<
				}
	
			<
		}
		-16166 {
			>
				emit {Compiled PSI (v2) data}
				if {[S string 3 0 {} {} > \0]} {
					>
						emit (%s)
					<
				}
	
			<
		}
		-16162 {
			>
				emit {Compiled PSI (v1) data}
			<
		}
		-14479 {
			>
				emit {byte-swapped cpio archive}
				mime {application/x-cpio # encoding: swapped}
			<
		}
		-13563 {
			>
				emit {huf output}
				mime application/octet-stream
			<
		}
		256 {
			>
				if {[S search 2 0 {} 9 eq \0\0]} {
					>
					<
				}
	

				emit {"compact bitmap" format (Poskanzer)}
			<
		}
		21845 {
			>
				emit {VISX image file}
				switch [Nv byte 2 0 {} {}] {
					-126 {
						>
							emit (graph)
						<
					}
					-125 {
						>
							emit {(adjacency graph)}
						<
					}
					-124 {
						>
							emit {(adjacency graph library)}
						<
					}
					0 {
						>
							emit (zero)
						<
					}
					1 {
						>

						<
					}
					126 {
						>
							emit {(bit vector)}
						<
					}















				}
	
				if {[S string 2 0 {} {} eq .VISIX]} {
					>
						emit {(ascii text)}
					<
				}

		}
		29127 {
			>
				emit {cpio archive}
				mime application/x-cpio
			<
		}







































	}
	
	if {[S string 0 0 {} {} eq AMANDA:\ ]} {
		>
			emit AMANDA
			if {[S string 8 0 {} {} eq TAPESTART\ DATE]} {
				>

			>
				emit {DR-DOS executable (COM)}
			<
		}
	}
	
	switch [Nv lelong 0 0 {} {}] {
		-2147417760 {
			>
				emit {MDEC video stream,}
				if {[N leshort 16 0 0 {} {} x {}]} {
					>
						emit %dx
					<
				}
	
				if {[N leshort 18 0 0 {} {} x {}]} {
					>
						emit {\b%d}
					<
				}
	
			<
		}
		-1728153892 {
			>
				if {[N uleshort 4 0 0 {} {} < 10]} {
					>
						emit {APT cache data, version %u}
						if {[N uleshort 6 0 0 {} {} x {}]} {
							>
								emit {\b.%u, 32 bit little-endian}
							<
						}
	
						U 15 apt-cache-32bit-be 0
	
					<
				}
	
				if {[N ubyte 4 0 0 {} {} > 9]} {
					>
						emit {APT cache data, version %u}
						if {[N ubyte 5 0 0 {} {} x {}]} {
							>
								emit {\b.%u, little-endian}
							<
						}
	
						U 15 apt-cache-be 0
	
					<
				}
	
			<
		}
		-1700603645 {
			>
				emit {Keepass password database}
				switch [Nv lelong 4 0 {} {}] {
					-1253311643 {
						>
							emit {1.x KDB}
							if {[N lelong 48 0 0 {} {} > 0]} {
								>
									emit {\b, %d groups}
								<
							}
	
							if {[N lelong 52 0 0 {} {} > 0]} {
								>
									emit {\b, %d entries}
								<
							}
	
							switch [Nv lelong 8 0 & 15] {
								1 {
									>
										emit {\b, SHA-256}
									<
								}
								2 {
									>
										emit {\b, AES}
									<
								}
								4 {
									>
										emit {\b, RC4}
									<
								}
								8 {
									>
										emit {\b, Twofish}
									<
								}
							}
	
							if {[N lelong 120 0 0 {} {} > 0]} {
								>
									emit {\b, %d key transformation rounds}
								<
							}
	
						<
					}
					-1253311641 {
						>
							emit {2.x KDBX}
						<
					}
				}
	
			<
		}
		-1641380927 {
			>
				emit {Unreal Engine Package,}
				if {[N leshort 4 0 0 {} {} x {}]} {
					>
						emit {version: %i}
					<
				}
	
				if {[N lelong 12 0 0 {} {} != 0]} {
					>
						emit {\b, names: %i}
					<
				}
	
				if {[N lelong 28 0 0 {} {} != 0]} {
					>
						emit {\b, imports: %i}
					<
				}
	
				if {[N lelong 20 0 0 {} {} != 0]} {
					>
						emit {\b, exports: %i}
					<
				}
	
			<
		}
		-1456779524 {
			>
				emit {Linux Software RAID}
				if {[N lelong 4 0 0 {} {} x {}]} {
					>
						emit {version 1.1 (%d)}
					<
				}
	
				U 129 linuxraid 0
	
			<
		}
		-1324630015 {
			>
				switch [Nv lelong 4 0 {} {}] {
					0 {
						>
							emit {Nintendo GameCube disc image (GCZ format)}
							mime application/x-gamecube-rom
						<
					}
					1 {
						>
							emit {Nintendo Wii disc image (GCZ format)}
							mime application/x-wii-rom
						<
					}
				}
	
				if {[D 4]} {
					>
						emit {Nintendo GameCube/Wii disc image (GCZ format)}
					<
				}
	
			<
		}
		-1040441407 {
			>
				emit {Common Trace Format (CTF) trace data (LE)}
			<
		}
		-681629056 {
			>
				emit {Cineon image data}
				if {[N belong 200 0 0 {} {} > 0]} {
					>
						emit {\b, %d x}
					<
				}
	
				if {[N belong 204 0 0 {} {} > 0]} {
					>
						emit %d
					<
				}
	
			<
		}
		-570294007 {
			>
				emit {locale archive}
				if {[N lelong 24 0 0 {} {} x {}]} {
					>
						emit {%d strings}
					<
				}
	
			<
		}
		-332356553 {
			>
				emit {Zstandard dictionary}
				mime application/x-zstd-dictionary
				if {[N lelong 4 0 0 {} {} x {}]} {
					>
						emit {(ID %u)}
					<
				}
	
			<
		}
		-316211398 {
			>
				emit {Android sparse image}
				if {[N leshort 4 0 0 {} {} x {}]} {
					>
						emit {\b, version: %d}
					<
				}
	
				if {[N leshort 6 0 0 {} {} x {}]} {
					>
						emit {\b.%d}
					<
				}
	
				if {[N lelong 16 0 0 {} {} x {}]} {
					>
						emit {\b, Total of %d}
					<
				}
	
				if {[N lelong 12 0 0 {} {} x {}]} {
					>
						emit {\b %d-byte output blocks in}
					<
				}
	
				if {[N lelong 20 0 0 {} {} x {}]} {
					>
						emit {\b %d input chunks.}
					<
				}
	
			<
		}
		-249691108 {
			>
				emit {magic binary file for file(1) cmd}
				if {[N lelong 4 0 0 {} {} x {}]} {
					>
						emit {(version %d) (little endian)}
					<
				}
	
			<
		}
		-109248628 {
			>
				emit {SE Linux policy}
				if {[N lelong 16 0 0 {} {} x {}]} {
					>
						emit v%d
					<
				}
	
				if {[N lelong 20 0 0 {} {} == 1]} {
					>
						emit MLS
					<
				}
	
				if {[N lelong 24 0 0 {} {} x {}]} {
					>
						emit {%d symbols}
					<
				}
	
				if {[N lelong 28 0 0 {} {} x {}]} {
					>
						emit {%d ocons}
					<
				}
	
			<
			>
				emit {SE Linux policy}
				if {[N lelong 16 0 0 {} {} x {}]} {
					>
						emit v%d
					<
				}
	
				if {[N lelong 20 0 0 {} {} == 1]} {
					>
						emit MLS
					<
				}
	
				if {[N lelong 24 0 0 {} {} x {}]} {
					>
						emit {%d symbols}
					<
				}
	
				if {[N lelong 28 0 0 {} {} x {}]} {
					>
						emit {%d ocons}
					<
				}
	
			<
			>
				emit {SE Linux policy}
				if {[N lelong 16 0 0 {} {} x {}]} {
					>
						emit v%d
					<
				}
	
				if {[N lelong 20 0 0 {} {} == 1]} {
					>
						emit MLS
					<
				}
	
				if {[N lelong 24 0 0 {} {} x {}]} {
					>
						emit {%d symbols}
					<
				}
	
				if {[N lelong 28 0 0 {} {} x {}]} {
					>
						emit {%d ocons}
					<
				}
	
			<
		}
		-109248625 {
			>
				emit {SE Linux modular policy}
				if {[N lelong 4 0 0 {} {} x {}]} {
					>
						emit {version %d,}
					<
				}
	
				if {[N lelong 8 0 0 {} {} x {}]} {
					>
						emit {%d sections,}
						if {[N lelong [I 12 ulelong 0 + 0 0] 0 0 {} {} == -109248627]} {
							>
								if {[N lelong [I 12 ulelong 0 + 0 27] 0 0 {} {} x {}]} {
									>
										emit {mod version %d,}
									<
								}
	
								switch [Nv lelong [I 12 ulelong 0 + 0 31] 0 {} {}] {
									0 {
										>
											emit {Not MLS,}
										<
									}
									1 {
										>
											emit MLS,
										<
									}
								}
	
								switch [Nv lelong [I 12 ulelong 0 + 0 23] 0 {} {}] {
									1 {
										>
											emit base
										<
									}
									2 {
										>
											if {[S string [I 12 ulelong 0 + 0 47] 0 {} {} > \0]} {
												>
													emit {module name %s}
												<
											}
	
										<
									}
								}
	
							<
						}
	
					<
				}
	
			<
		}
		-47205086 {
			>
				emit {Zstandard compressed data (v0.2)}
				mime application/x-zstd
			<
		}
		-47205085 {
			>
				emit {Zstandard compressed data (v0.3)}
				mime application/x-zstd
			<
		}
		-47205084 {
			>
				emit {Zstandard compressed data (v0.4)}
				mime application/x-zstd
			<
		}
		-47205083 {
			>
				emit {Zstandard compressed data (v0.5)}
				mime application/x-zstd
			<
		}
		-47205082 {
			>
				emit {Zstandard compressed data (v0.6)}
				mime application/x-zstd
			<
		}
		-47205081 {
			>
				emit {Zstandard compressed data (v0.7)}
				mime application/x-zstd
				U 50 zstd-dictionary-id 4
	
			<
		}
		-47205080 {
			>
				emit {Zstandard compressed data (v0.8+)}
				mime application/x-zstd
				U 50 zstd-dictionary-id 4
	
			<
		}
		-21555 {
			>
				emit {MLSSA datafile,}
				if {[N leshort 4 0 0 {} {} x {}]} {
					>
						emit {algorithm %d,}
					<
				}
	
				if {[N lelong 10 0 0 {} {} x {}]} {
					>
						emit {%d samples}
					<
				}
	
			<
		}
		1 {
			>
				if {[N lelong 4 0 0 {} {} == 100]} {
					>
						if {[N lelong 8 0 0 {} {} == 10000]} {
							>
								if {[N lelong 12 0 0 {} {} == 50]} {

	
				if {[N leshort 30 0 0 {} {} & 16384]} {
					>
						emit V2.3
					<
				}
	
				if {[N leshort 30 0 0 {} {} & -32768]} {
					>
						emit V3.0
					<
				}
	
				if {[N byte 28 0 0 {} {} & 4]} {
					>

				emit {LZ4 compressed data (v1.4+)}
				mime application/x-lz4
			<
		}
		453186358 {
			>
				emit {L	Netboot image,}
				if {[N lelong 4 0 0 & -256 == 0]} {
					>
						switch [Nv lelong 4 0 & 256] {
							0 {
								>
									emit {mode 2}
								<
							}
							256 {
								>
									emit {mode 3}
								<
							}
						}
	
					<
				}
	
				if {[N lelong 4 0 0 & -256 != 0]} {
					>
						emit {unknown mode}
					<
				}
	
			<
		}

	
				if {[N byte 36 0 0 {} {} x {}]} {
					>
						emit {\b.%d}
					<
				}
	























































































































































































































































































































































































































































































			<
		}
	}
	
	if {[S string 0 0 {} {} eq MOVI]} {
		>
			emit {Silicon Graphics movie file}

					emit {\b, Samsung stereo, dual stream (patent pending)}
				<
			}
	
		<
	}
	
	switch [Nv belong 0 0 & -256] {
		-2063526912 {
			>
				emit {cisco IOS microcode}
				if {[S string 7 0 {} {} > \0]} {
					>
						emit {for '%s'}
					<
				}
	
			<
		}
		-2063480064 {
			>
				emit {cisco IOS experimental microcode}
				if {[S string 7 0 {} {} > \0]} {
					>
						emit {for '%s'}
					<
				}
	
			<
		}
		-16907008 {
			>
				emit {MySQL ISAM index file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
			<
		}
		-16906752 {
			>
				emit {MySQL ISAM compressed data file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
			<
		}
		-16906496 {
			>
				emit {MySQL MyISAM index file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
				if {[N beshort 14 0 0 {} {} x {}]} {
					>
						emit {\b, %d key parts}
					<
				}
	
				if {[N beshort 16 0 0 {} {} x {}]} {
					>
						emit {\b, %d unique key parts}
					<
				}
	
				if {[N byte 18 0 0 {} {} x {}]} {
					>
						emit {\b, %d keys}
					<
				}
	
				if {[N bequad 28 0 0 {} {} x {}]} {
					>
						emit {\b, %lld records}
					<
				}
	
				if {[N bequad 36 0 0 {} {} x {}]} {
					>
						emit {\b, %lld deleted records}
					<
				}
	
			<
		}
		-16906240 {
			>
				emit {MySQL MyISAM compressed data file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
			<
		}
		-16905984 {
			>
				emit {MySQL Maria index file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
			<
		}
		-16905728 {
			>
				emit {MySQL Maria compressed data file}
				if {[N byte 3 0 0 {} {} x {}]} {
					>
						emit {Version %d}
					<
				}
	
			<
		}
		-16905216 {
			>
				if {[S string 4 0 {} {} eq MACF]} {
					>
						emit {MySQL Maria control file}
						if {[N byte 3 0 0 {} {} x {}]} {
							>
								emit {Version %d}
							<
						}
	
					<
				}
	
			<
		}
		256 {
			>
				switch [Nv byte 3 0 {} {}] {
					-80 {
						>
							emit {MPEG sequence, v4}
							mime video/mpeg4-generic
							if {[N belong 5 0 0 {} {} == 437]} {
								>
									if {[N byte 9 0 0 {} {} & -128]} {
										>
											switch [Nv byte 10 0 & -16] {
												16 {
													>
														emit {\b, video}
													<
												}
												32 {
													>

													<
												}
											}
	
										<
									}
	
									switch [Nv byte 9 0 & -8] {
										8 {
											>
												emit {\b, video}
											<
										}
										16 {
											>

										}
									}
	
								<
							}
	
							switch [Nv byte 4 0 {} {}] {































































































								-127 {
									>
										emit {\b, hybrid @ L1}
									<
								}
								-126 {
									>

									<
								}
								-3 {
									>
										emit {\b, FGS @ L5}
									<
								}
								1 {
									>
										emit {\b, simple @ L1}
									<
								}
								2 {
									>
										emit {\b, simple @ L2}
									<
								}
								3 {
									>
										emit {\b, simple @ L3}
									<
								}
								4 {
									>
										emit {\b, simple @ L0}
									<
								}
								17 {
									>
										emit {\b, simple scalable @ L1}
									<
								}
								18 {
									>
										emit {\b, simple scalable @ L2}
									<
								}
								33 {
									>
										emit {\b, core @ L1}
									<
								}
								34 {
									>
										emit {\b, core @ L2}
									<
								}
								50 {
									>
										emit {\b, main @ L2}
									<
								}
								51 {
									>
										emit {\b, main @ L3}
									<
								}
								53 {
									>
										emit {\b, main @ L4}
									<
								}
								66 {
									>
										emit {\b, n-bit @ L2}
									<
								}
								81 {
									>
										emit {\b, scalable texture @ L1}
									<
								}
								97 {
									>
										emit {\b, simple face animation @ L1}
									<
								}
								98 {
									>
										emit {\b, simple face animation @ L2}
									<
								}
								99 {
									>
										emit {\b, simple face basic animation @ L1}
									<
								}
								100 {
									>
										emit {\b, simple face basic animation @ L2}
									<
								}
								113 {
									>
										emit {\b, basic animation text @ L1}
									<
								}
								114 {
									>
										emit {\b, basic animation text @ L2}
									<
								}
							}
	
						<
					}
					-77 {
						>
							emit {MPEG sequence}

											5 {
												>
													emit {\b SP}
												<
											}
										}
	
										switch [Nv byte 17 0 & -16] {
											-128 {
												>
													emit {\b@ML}
												<
											}
											-96 {
												>
													emit {\b@LL}
												<
											}
											64 {
												>
													emit {\b@HL}
												<
											}
											96 {
												>
													emit {\b@H-14}
												<
											}










										}
	
										if {[N byte 17 0 0 {} {} & 8]} {
											>
												emit {\b progressive}
											<
										}

															5 {
																>
																	emit {\b SP}
																<
															}
														}
	
														switch [Nv byte 145 0 & -16] {
															-128 {
																>
																	emit {\b@ML}
																<
															}
															-96 {
																>
																	emit {\b@LL}
																<
															}
															64 {
																>
																	emit {\b@HL}
																<
															}
															96 {
																>
																	emit {\b@H-14}
																<
															}










														}
	
														if {[N byte 145 0 0 {} {} & 8]} {
															>
																emit {\b progressive}
															<
														}

											5 {
												>
													emit {\b SP}
												<
											}
										}
	
										switch [Nv byte 81 0 & -16] {
											-128 {
												>
													emit {\b@ML}
												<
											}
											-96 {
												>
													emit {\b@LL}
												<
											}
											64 {
												>
													emit {\b@HL}
												<
											}
											96 {
												>
													emit {\b@H-14}
												<
											}










										}
	
										if {[N byte 81 0 0 {} {} & 8]} {
											>
												emit {\b progressive}
											<
										}

								440 {
									>
										emit {\b, v1, progressive Y'CbCr 4:2:0 video}
									<
								}
							}
	
							switch [Nv belong 4 0 & -256] {
								167802880 {
									>
										emit {\b, 160x120}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 4:3}
											<
										}
	
									<
								}
								251699200 {
									>
										emit {\b, 240x160}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 4:3}
											<
										}
	
									<
								}
								335605760 {
									>
										emit {\b, 320x240}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 4:3}
											<
										}
	
									<
								}
								671211520 {
									>
										emit {\b, LD-TV 640P}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 4:3}
											<
										}
	
									<
								}
								805453824 {
									>
										emit {\b, PAL Capture}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 4:3}
											<
										}
	
									<
								}
								1342188800 {
									>
										emit {\b, SD-TV 1280I}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 16:9}
											<
										}
	
									<
								}
								2013542400 {
									>
										emit {\b, HD-TV 1920P}
										if {[N byte 7 0 0 & -16 == 16]} {
											>
												emit {\b, 16:9}
											<
										}
	
									<
								}
							}
	
							switch [Nv beshort 4 0 & -16] {
								5632 {
									>
										emit {\b, CIF}
										switch [Nv beshort 5 0 & 4095] {
											240 {
												>
													emit {\b NTSC}
												<
											}
											288 {
												>
													emit {\b PAL}
												<
											}
											576 {
												>
													emit {\b PAL 625}
													switch [Nv byte 7 0 & -16] {
														32 {
															>
																emit {\b, 4:3}
															<
														}
														48 {
															>

														}
													}
	
												<
											}
										}
	
										switch [Nv byte 7 0 & -16] {
											-128 {
												>
													emit {\b, PAL 4:3}
												<
											}
											-64 {
												>
													emit {\b, NTSC 4:3}
												<
											}
											32 {
												>
													emit {\b, 4:3}
												<
											}
											48 {
												>
													emit {\b, 16:9}
												<
											}
											64 {
												>
													emit {\b, 11:5}
												<
											}










										}
	
									<
								}
								7680 {
									>
										emit {\b, SVCD}
										switch [Nv beshort 5 0 & 4095] {
											480 {
												>
													emit {\b NTSC 525}
												<
											}
											576 {
												>
													emit {\b PAL 625}
												<
											}
										}
	
										switch [Nv byte 7 0 & -16] {
											32 {
												>
													emit {\b, 4:3}
												<
											}
											48 {
												>

											576 {
												>
													emit {\b PAL}
												<
											}
										}
	
										switch [Nv byte 7 0 & -16] {
											-128 {
												>
													emit {\b, PAL 4:3}
												<
											}
											-64 {
												>
													emit {\b, NTSC 4:3}
												<
											}
											32 {
												>
													emit {\b, 4:3}
												<
											}
											48 {
												>
													emit {\b, 16:9}
												<
											}
											64 {
												>
													emit {\b, 11:5}
												<
											}










										}
	
									<
								}
								11520 {
									>
										emit {\b, CCIR/ITU}
										switch [Nv beshort 5 0 & 4095] {
											480 {
												>
													emit {\b NTSC 525}
												<
											}
											576 {
												>
													emit {\b PAL 625}
												<
											}
										}
	
										switch [Nv byte 7 0 & -16] {
											32 {
												>
													emit {\b, 4:3}
												<
											}
											48 {
												>

	
						<
					}
					-75 {
						>
							emit {MPEG sequence, v4}
							mime video/mpeg4-generic
							if {[N byte 4 0 0 {} {} & -128]} {
								>
									switch [Nv byte 5 0 & -16] {
										16 {
											>
												emit {\b, video (missing profile header)}
											<
										}
										32 {
											>

											<
										}
									}
	
								<
							}
	
							switch [Nv byte 4 0 & -8] {
								8 {
									>
										emit {\b, video (missing profile header)}
									<
								}
								16 {
									>

	
				if {[N byte 4 0 0 {} {} ^ 1]} {
					>
						emit {(DV) movie file}
					<
				}
	
				if {[N byte 3 0 0 {} {} & -128]} {
					>
						emit (PAL)
					<
				}
	
				if {[N byte 3 0 0 {} {} ^ -128]} {
					>
						emit (NTSC)
					<
				}
	
			<
		}







	}
	































































































































	switch [Nv beshort 0 0 & -2] {
		-30 {
			>
				emit {MPEG ADTS, layer III,  v2.5}
				mime audio/mpeg
				switch [Nv byte 2 0 & -16] {
					-128 {
						>
							emit {\b,  64 kbps}
						<
					}
					-112 {
						>
							emit {\b,  80 kbps}
						<
					}
					-96 {
						>
							emit {\b,  96 kbps}
						<
					}
					-80 {
						>
							emit {\b, 112 kbps}
						<
					}
					-64 {
						>
							emit {\b, 128 kbps}
						<
					}
					-48 {
						>
							emit {\b, 144 kbps}
						<
					}
					-32 {
						>
							emit {\b, 160 kbps}
						<
					}
					16 {
						>
							emit {\b,   8 kbps}
						<
					}
					32 {
						>
							emit {\b,  16 kbps}
						<
					}
					48 {
						>
							emit {\b,  24 kbps}
						<
					}
					64 {
						>
							emit {\b,  32 kbps}
						<
					}
					80 {
						>
							emit {\b,  40 kbps}
						<
					}
					96 {
						>
							emit {\b,  48 kbps}
						<
					}
					112 {
						>
							emit {\b,  56 kbps}
						<
					}
				}
	
				switch [Nv byte 2 0 & 12] {
					0 {
						>
							emit {\b, 11.025 kHz}
						<
					}
					4 {
						>
							emit {\b, 12 kHz}
						<
					}
					8 {
						>
							emit {\b, 8 kHz}
						<
					}
				}
	
				switch [Nv byte 3 0 & -64] {
					-128 {
						>
							emit {\b, 2x Monaural}
						<
					}
					-64 {
						>
							emit {\b, Monaural}
						<
					}
					0 {
						>
							emit {\b, Stereo}
						<
					}
					64 {
						>
							emit {\b, JntStereo}
						<
					}
				}
	
			<
		}
		-14 {
			>
				emit {MPEG ADTS, layer III, v2}
				mime audio/mpeg
				switch [Nv byte 2 0 & -16] {
					-128 {
						>
							emit {\b,  64 kbps}
						<
					}
					-112 {
						>
							emit {\b,  80 kbps}
						<
					}
					-96 {
						>
							emit {\b,  96 kbps}
						<
					}
					-80 {
						>
							emit {\b, 112 kbps}
						<
					}
					-64 {
						>
							emit {\b, 128 kbps}
						<
					}
					-48 {
						>
							emit {\b, 144 kbps}
						<
					}
					-32 {
						>
							emit {\b, 160 kbps}
						<
					}
					16 {
						>
							emit {\b,   8 kbps}
						<
					}
					32 {
						>