yg(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'None+M+Hack to catch "pureish" asynchronous errorsThis is only used as a workaround to the binary library's shortcoming of using asynchronous errors instead of pure error handling, and also zlib's same shortcoming. This function is similar to the spoon package's teaspoonS function, except that it can return more information when an exception is caught.Return a substring index length returns length) characters from the string starting at index, which starts at 0. subStr 1 2 "abcd" == "bc"((None+LFormats for raw image data that don't include information such as dimensions^Series of unused byte, red, green, and blue; the string is compressed and then base-64 encoded+Series of unused byte, red, green, and blue?Series of red, green, blue, red, etc. with a row alignment of 4SSeries of red, green, blue, red, etc. with a row alignment of 4, stored upside-downUSeries of blue, green, red, unused, blue, etc. (already aligned to a 4-byte boundary) hSeries of blue, green, red, unused, blue, etc. stored upside-down (already aligned to a 4-byte boundary) TSeries of blue, green, red, blue, etc. with a row alignment of 4, stored upside-down LSeries of red, green, and blue, represented as a series of hexadecimal pairs qSeries of unused byte, red, green, and blue; the string is compressed and then base-64 encoded; identified by an l character Series of red, green, and blue; the string is hex encoded, then compressed, then hex encoded again; the encoded string is prepended with with zSeries of blue, green, and red, that is rotated two bytes right; the string is compressed and then base-64 encoded; the encoded string is prepended with a b for simpler identification{Series of red, green, and blue; the string is compressed and then base-64 encoded; the encoded string is prepended with an m for simpler identification/Formats that bitmaps that are instances of the BitmapL class need to support; these formats include the necessary meta-informationESimilar to CBF_BMPIU, but internally the pixel data is stored in the   format instead of  4This format is another common format of "bmp" files.Same as  except that that final result is base-64 encoded and is thus suitable for human-readable strings defining a small bitmap (CompleteBitmapFormat_BitMaPInfoheaderUncompressed)Like , strings encoded in this format can become large quick quickly, and even about a third more so, due to the more restrictive range of values.\Uncompressed BITMAPINFOHEADER BMP format (CompleteBitmapFormat_BitMaPInfoheaderUncompressed)#The image format of this format is  Due to being uncompressed, strings encoded in this format can grow large quite quickly. This format is standard and widely supported, and can be written directly to a file, the extension of which is typically ".bmp"3This format is one possible format for "bmp" files.9These are the color depths that the bitmap class supportsThe depth does not necessarily indicate any particular order; instead the components listed in the name indicate which components are contained in each pixel.[The order in which the constructors are defined is significant; it determines which match mostLikelyMatchCBF will choose.X32 bit pixel also consisting of one pixel per component but contains the alpha componentFFour bytes are needed for pixels of this type to be fully represented.Q24 bit pixel consisting of one pixel per component and lacking an alpha componentEach pixel of this type thus requires three bytes to be fully represented. Implementations are not required to pack the image data, however; they are free, for instance, to store each pixel in 32-bit (4-byte) integers.     None+MNone+M )*   )*)None+BJK#WGeneric pixel type which has not be efficient enough when used with bitmaps in practice&#The most significant byte is unused'#The most significant byte is unusedL=A less efficient way of converting pixels by their componentsOiIf the Genpixel types differ, they can still be determined to be equivalent if their components are equal+Unlike the default derived instance of Eq, PiIf the Genpixel types differ, they can still be determined to be equivalent if their components are equal+Unlike the default derived instance of Eq, ^oReturn a color from the first 6-bytes of a string representing the red, green, and blue components of the color y(colorString "FF0000" :: Maybe PixelRGBA) == Just $ (red =: 0xFF) . (green =: 0x00) . (blue =: 0x00) $ greatestIntensityU!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN+OP,-QRSTUVWXYZ[\]^./0123456789:;<=>?@A>!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ACDEFGHIJKLBAMN>?@;<=89:567234/01,-.)*+#'&%$((((OPQRSTUVWX"!YZ[\]^8!"#'&%$(((()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN+OP,-QRSTUVWXYZ[\]^./0123456789:;<=>?@ANone +3=EHKMn Bitmap classPixels are indexed by (row, column), where (0, 0) represents the upper-left-most corner of the bitmap. Instances of this class are not required to support empty bitmaps.bThe encoding and decoding lists contain functions that can encode and decode or return a string containing information about why it could not be decoded in that format. The order is important: When a function tries multiple or any decoder, it will use or return the one(s) closest to the head of the list. There are lists of generic functions that are defined by default. Normally, if an implementation of a bitmap type overrides the default instance, it will only need to replace one or a few decoders, not touching the rest of the default decoders or the order of the decoders; thus the function { is defined and exported.4Instances *must* support every serialization format.z"Convert one bitmap type to another{Update identifiable elements{ orig new returns orig> with each matching pair updated; extraneous replacements in new are ignored.Encode a bitmap|An implementation can choose the most efficient or appropriate format by placing its encoder first in its list of encoders.Decode a bitmapeThe result of first decoder of the implementation that succeeds will be returned. If none succeed, B is returned.Encode the pixels of a bitmap|An implementation can choose the most efficient or appropriate format by placing its encoder first in its list of encoders.Decode the pixels of a bitmapeThe result of first decoder of the implementation that succeeds will be returned. If none succeed, B is returned.&Encode a bitmap in a particular format&Decode a bitmap in a particular format4Encode the pixels of a bitmap in a particular format4Decode the pixels of a bitmap in a particular format)Decode an image with the given dimensionsThis is only guaranteed to work on implementations and formats that only need dimensions in addition to the raw pixel data. This is convenient because most often the dimensions are all that is needed.Currently, this function works by constructing a bitmap with the given dimensions and with each pixel set to the least intensity. Thus it is significantly more efficient if this is used with a bitmap that doesn't strictly evaluate the entire pixel data when the structure is first constructed (not necessarily when any pixel is accessed) (currently none of the bitmap types exported in this library are so strict), as the bitmap will not need to be fully evaluated; only the dimensions will be used.-Decode an image with the given dimensions as " does it, but in a specific formatZDetermine whether the seconds dimensions passed can fit within the first dimensions passedTIf the width or height of the second dimensions exceeds those of first dimensions, C is returned.Returns the width of a bitmapReturns the height of a bitmapO_`abcdefghijklmnopq%The color depth of the bitmap in bitsr3Return the width and height of the bitmap in pixelss!Get a pixel; indexing starts at 0Implementations can assume that the coordinates are within the bounds of the bitmap. Thus callers of this function should always ensure that the coordinates are within the bounds of the bitmap.teConstruct a bitmap with a function that returns a pixel for each coordinate with the given dimensionsFThe function should return the same type of pixel for each coordinate.Implementations are not required to call the function in any particular order, and are not even required to guarantee that the function will be called for each pixel, which might be true for a bitmap that is evaluated lazily as needed.uConstruct a new bitmap from the bitmap passed as the second argument but storing it in the bitmap of the meta-bitmap passed as the first argumentOThe purpose of this function is efficiency. Some bitmap types have multiple possible internal representations of bitmaps. For these bitmap types, it is often more efficient when performing operations on multiple bitmaps for them be stored in the same format. Instances might even always convert the bitmaps if their formats differ.Implementations are not required to define this function to store the second bitmap in another format, or even in the same format as the first bitmap; this is only used for efficiency. They should, however, return a bitmap that represents the same bitmap as what the main bitmap (passed as the second argument) represents. The default behaviour of this function is to return the main bitmap (passed second) verbatim.^As an example application of this function, consider a program that regularly captures the screen and searches for any of several bitmaps which are read from the filesystem. The programmer chooses the type that is most efficient for the format that the screen capture is in, and uses it as the main type. As the screen is expected to change, it would be inefficient to convert each capture into another internal format each time, especially since screen dumps can be very large. The bitmaps, however, are generally static (and much smaller), so they could be converted once using this function, u, to the format that screen captures are represented in, and reused. If the formats would otherwise differ, this is much more efficient than converting the format of every sub-bitmap every time a search or operation is needed.NB: again, the format of the first argument is used along with the image of the second argument to return (possibly) a bitmap with the image of the second argument and with the format of the first argument.v0Bitmap encoders; default definition is based on |As the head of the list might be best suited for writing to files or generating text strings but not both, it is suggested that this function is used only when it does not matter whether the result is writable to a file or is generally "human readable".wdBitmap decodes; extra bytes after the end should be ignored by them; default definition is based on xNBitmap encoders; the meta-information is lost; default definition is based on yKDecode the bitmap; the meta-information from the given bitmap is used (see b"); default definition is based on z{|}~DN_`abcdefghijklmnopqrstuvwxyz{|}~Nnopqrstuvwxyzklmhijefgbcd_`a{|}~:_`abcdefghijklmn opqrstuvwxyz{|}~DNone+=BKArrays of 32-bit RGBA pixelsEInstance for debugging purposesFEFENone+ None+24QClass for bitmaps that can be rectangularly cropped into (possibly) smaller sizesUsing the functions of the n class, default functions are be defined for each of these; of course, implementations are free to write more efficient versions.ZCrop a bitmap with the given dimensions (third argument) from a position (second argument)Implementations can but are not required to assume that the result will be a (not necessarily proper) subset of the super bitmap only. Implementations should properly handle the case where the result is as large as the passed super bitmap.GG None+24Class for reflectable bitmapsUsing the functions of the n class, default functions are be defined for each of these; of course, implementations are free to write more efficient versions.HH None+=KM5The foreign bitmap as defined by the "bitmap" package?For more information see documentation of the "bitmap" package.NB: this type is actually a reference to a memory location; thus the possible issues with concurrency and referential transparency are introduced.II None+24M Class for searchable bitmapsUsing the functions of the n class, default functions are be defined for each of these; of course, implementations are free to define more efficient versions.Recursively call a function with the coordinates, row by row from the left, from the minimum, upper-left coordinates to the maximum, lower-right coordinates=Scan each pixel until a match is found in no particular ordertImplementations are free to choose an efficient implementation that searches in a different direction from that of D. This function is often, but not necessarily always, the same as ._Scan each pixel, row by row from the left, starting at the given offset, until a match is foundA more restricted version of > that is usually more efficient when exact equality is desired5Search for coordinates where a sub-bitmap would matchEach coordinate, representing the upper-left-most corner, for which the sub-bitmap would fit is tried for a match until the function returns J for every pixel that is compared. The function is passed the pixel of the super bitmap which is searched as the first parameter, and the pixel of the sub bitmap is passed as the second parameter. Likewise, the super bitmap is then given to this function as the second parameter, and then the sub bitmap. Normally, the order in which the bitmap is checked in the same order as , but implementation are free to implement this in whatever order is convenient or efficient; implementation should, however, assume that callers usually expect this order to be the most efficient one.A more restricted version of > that is usually more efficient when exact equality is desiredFind the first bitmap from the list that matches with the area of the same size from the given coordinate in the "super" bitmap (passed as the second argument) down-right (the coordinate is the first pixel which is the top-left most of the area to check). The match sub-bitmap and its index in the list are passed in the opposite order given in this description to the function, and the result is returned; if one is found. If no match is found, B is returned.The "sub" bitmaps are tested in order until a match is found, and if one is, its index in the list is returned. Each pixel in every "sub" bitmap is specially colored to represent a particular function. These colors are recognized:nblack / greatest intensity: the corresponding pixel in the "super" bitmap based on position can be any color.white / least intensity: the corresponding pixel in the super bitmap must be the same color as every other pixel in the super bitmap that also corresponds to a white pixel.red  FF0000  completely red: if there are white pixels in the sub bitmap, the corresponding pixel of the red pixel should be different from the color that corresponds to the white pixels.green  00FF00  complete green: if there are white pixels in the sub bitmap, the corresponding pixel of the green pixel should not be similar from the color that corresponds to the white pixels. Seeyellow  FFFF00  complete yellow: if there are white pixels, this matches iff the color is similar to the colors that correspond to the white pixels.; to see whether two colors are considered to be "similar".@The behaviour when any other pixel is encountered is undefined.When the dimensions of a sub bitmap are too large for the super bitmap offset by the coordinates, where otherwise some pixels of the sub bitmap would not have any corresponding pixels in the super bitmap; then the sub bitmap simply does not match.SThis function makes OCR with a known and static font more convenient to implement.K equivalent of , for a horizontal string of embedded bitmaps^This is particularly convenient for OCR with a static and known font with multiple characters.AScan for the given string of horizontally embedded bitmaps as in As with , each bitmap must be adjacent to match. If the integer is passed for a dimension ("(width, height)"), then no more than "the value" extra rows or columns will be checked. For example, if L 0G is passed for the row value, then no additional rows will be checked.Binary similarity comparisonnThis function considers two colors to be "similar" if their difference according to the CIE94 algorithm (see ) is less than 23.@Approximate difference in color according to the CIE94 algorithm'Default transparent pixel value; FF007EStarting valueMinimum, upper-left coordinates Maximum, lower-right coordinates'The bitmap in which to scan coordinates Super bitmap Sub bitmap Super bitmap Sub bitmap Super bitmap Sub bitmap Super bitmap Sub bitmap Super bitmap Sub bitmap Super bitmap$Coordinates relative to super bitmap Super bitmap Super bitmapM M None+=KNNNone+None+=K3A bitmap represented as a string or stored as bytesfBy default, the RGB32 format (where the most significant byte, the head-most one, is unused) is used.QThe bitmap must be stored by pixels not separated by component. Each pixel must contain at least the red, blue, and green component, each one byte wide (bytes are assumed to be octets), either in that order or reversed. There may be an alpha component either immediately before the other three components or immediately after. Thus there are four possible arrangements of components for each pixel, which must be consistent for every pixel. Any amount of padding or unused bytes is permitted before each pixel, but the amount must be fixed. The same is true also after each pixel.2This type is most efficient with lazy bytestrings.-Bitmap data; it is assumed to be large enoughWidth and height of the data; @, etc. need to be taken account for the dimensions of the bitmapXEach row is aligned to this many bytes; when necessary, null bytes are added to each row'Whether the red component is first; if JT, the order of the components is red, green, blue; otherwise, it is blue, green, redIf B2, then there is no alpha component; otherwise, if J=, it is before the other three components (towards the head)  most significant : first, otherwise, it is after the other three components  towards the tail 0 least significant / last of the four components(Number of unused bytes before each pixel'Number of unused bytes after each pixelIs the first row at the top?,Is the first column in each row at the left?UHow many rows of data to skip from the beginning (from *first* row); used in cropping<How many rows of data to skip from the end; used in croppingDefault  formatThis is equivalent to LReturn (rowSize, paddingSize) based on width, bytes per pixel, and alignment^Be careful when using the results of this function that you're actually using the right value.Return (rowSize, paddingSize)^Be careful when using the results of this function that you're actually using the right value.!Get part of a pixel as a cell of GenStringDefaultThe bitmap passed is only used for its format; its dimensions and data are not used. This function doesn't return any alpha parts; for those it returns pad bytes, which are zero.:Construct a bitmap in the format of the meta bitmap passedVOnly the format fields of the bitmap is used, so the data and dimensions of it can be O.#The data in the new bitmap is what GenStringDefault is aliased to.Used by the encodersUsed by the decoders9   PQRST4   4   +   PQRSTNone+None+ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None +:=EJKM  A bitmap represented as a stringThis is essentially the format of pixels in the BMP format in which each row is aligned to a four-byte boundry and each row contains a series of RGB pixels.LThis type is most efficient for programs interacting heavily with BMP files.Width and height of the bitmapData stored in a stringzContainer for a string that represents a sequence of raw pixels lacking the alpha component and that is stored upside downLReturn (rowSize, paddingSize) based on width, bytes per pixel, and alignment  UVWXYZ      UVWXYZNone+  None +:=EJKMA bitmap represented as a string, which contains a series of aligned rows, which themselves consist of a series of pixels stored in 4 bytes in which the most significant byte is unused (thus the rows are always aligned to a four-byte boundary)Width and height of the bitmapData stored in a string !Polymorphic container of a string !"[#$%&'\]^_`  !"#$%&'  !"$#%&'  !"[#$%&'\]^_`None+a !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKKLMMNOOPQQRSTUVWXYZ[\]^_`abcdefghijklmnopqqrsstuuvwwxyyz{|}~                !"#$%&'()*+,-./0123456789:;<=>? @ A B:;C7DE78F G H7IJKLMNOPQRSTUPVWXYZ[bitmaps-0.2.6.3Data.Bitmap.UtilData.Bitmap.TypesCodec.String.Base64Codec.String.Base16Data.Bitmap.PixelData.Bitmap.ClassData.Bitmap.Array.InternalData.Bitmap.ArrayData.Bitmap.CroppableData.Bitmap.ReflectableData.Bitmap.ForeignData.Bitmap.SearchableData.Bitmap.Function.InternalData.Bitmap.String.Internal$Data.Bitmap.StringRGB24A4VR.Internal Data.Bitmap.StringRGB32.InternalData.Bitmap.FunctionData.Bitmap.StringData.Bitmap.BMPData.Bitmap.StringRGB24A4VRData.Bitmap.StringRGB32 tablespoonsubStrpadByteImageBitmapFormat IBF_RGB32Z64 IBF_RGB32 IBF_RGB24A4 IBF_RGB24A4VR IBF_BGRU32 IBF_BGRU32VR IBF_BGR24A4VR IBF_BGR24HIBF_IDRGB32Z64IBF_IDBGR24HZHIBF_IDBGR24R2RZ64IBF_IDRGB24Z64CompleteBitmapFormat CBF_BMPIUU CBF_BMPIUZ64 CBF_BMPIU64 CBF_BMPIUDepth Depth32RGBA Depth24RGB Coordinates Dimensionsbytes64ibytes64 fillByte64encode64decode64 encodeHex decodeHexGenPixelComponentGenPixelStorageGenPixel GenPixelBGRA GenPixelRGBA GenPixelBGR GenPixelRGBunwrapPixelStorage ConvPixelBGRA toPixelBGRA fromPixelBGRA ConvPixelRGBA toPixelRGBA fromPixelRGBA ConvPixelBGR toPixelBGR fromPixelBGR ConvPixelRGB toPixelRGB fromPixelRGB PixelBGRAunwrapPixelBGRA PixelRGBAunwrapPixelRGBAPixelBGRunwrapPixelBGRPixelRGBunwrapPixelRGBPixelComponent PixelStoragePixelredgreenbluealphaleastIntensitygreatestIntensitytoPixel fromPixelconvertPixelValueleastIntensityComponentgreatestIntensityComponenteqGenPixelValueneqGenPixelValuegenRedgenGreengenBluegenAlpha toGenPixelRGB toGenPixelBGRtoGenPixelRGBAtoGenPixelBGRAleastIntensityGenComponentgreatestIntensityGenComponentleastIntensityGengreatestIntensityGen bigEndian colorStringGenericBitmapSerializerunwrapGenericBitmapSerializer ImageDecoderunwrapImageDecoder ImageEncoderunwrapImageEncoderCompleteDecoderunwrapCompleteDecoderCompleteEncoderunwrapCompleteEncoderBitmap BIndexType BPixelTypedepth dimensionsgetPixelconstructPixelsconvertInternalFormatcompleteEncoderscompleteDecoders imageEncoders imageDecoders convertBitmapupdateIdentifiableElementsdefaultCompleteEncodersencodeCBF_BMPIUencodeCBF_BMPIUUencodeCBF_BMPIU64encodeCBF_BMPIUZ64defaultCompleteDecoders tryCBF_BMPIU tryCBF_BMPIUUtryCBF_BMPIU64tryCBF_BMPIUZ64defaultImageEncodersencodeIBF_IDRGB24Z64encodeIBF_IDBGR24R2RZ64encodeIBF_IDBGR24HZHencodeIBF_IDRGB32Z64encodeIBF_BGR24HencodeIBF_RGB24A4encodeIBF_BGR24A4VRencodeIBF_BGRU32VRencodeIBF_BGRU32encodeIBF_RGB24A4VRencodeIBF_RGB32encodeIBF_RGB32Z64defaultImageDecoderstryIBF_IDRGB24Z64tryIBF_IDBGR24R2RZ64tryIBF_IDBGR24HZHtryIBF_IDRGB32Z64 tryIBF_BGR24HtryIBF_RGB24A4tryIBF_BGR24A4VRtryIBF_BGRU32VR tryIBF_BGRU32tryIBF_RGB24A4VR tryIBF_RGB32tryIBF_RGB32Z64encodeCompletedecodeComplete encodeImage decodeImageencodeCompleteFmtdecodeCompleteFmtencodeImageFmtdecodeImageFmtdecodeImageDimensionsdecodeImageDimensionsFmt dimensionsFit bitmapWidth bitmapHeight BitmapArrayunwrapBitmapArraybitmapArrayToArraybitmapArrayToBitmapArrayBitmapCroppablecropBitmapReflectablereflectVerticallyreflectHorizontally BitmapForeignunwrapBitmapForeign FBBitmapBaseBitmapSearchable foldrCoords findPixelfindPixelOrderfindPixelEqual findPixelsfindPixelsEqual findSubBitmapfindSubBitmapOrderfindSubBitmapEqualfindSubBitmapsfindSubBitmapsEqualfindEmbeddedBitmapfindEmbeddedBitmapStringfindFixedEmbeddedBitmapStringareColorsSimilarcolorDifferenceCIE94defaultTransparentPixel matchPixelAnymatchPixelSamematchPixelSameThreshold matchPixelDifmatchPixelDifThresholdBitmapFunction_bmpf_dimensions_bmpf_getPixelbmpf_dimensions bmpf_getPixel BitmapString _bmps_data_bmps_dimensions_bmps_rowAlignment _bmps_redHead_bmps_alphaHead_bmps_paddingHead_bmps_paddingTail_bmps_rowFromTop_bmps_columnFromLeft_bmps_rowFromBeg_bmps_rowFromEnd_bmps_columnFromBeg_bmps_columnFromEndbmps_alphaHeadbmps_columnFromBegbmps_columnFromEndbmps_columnFromLeft bmps_databmps_dimensionsbmps_paddingHeadbmps_paddingTail bmps_redHeadbmps_rowAlignmentbmps_rowFromBegbmps_rowFromEndbmps_rowFromTopformatEqdefaultBSFormat rowPadding bytesPerPixel rowPaddingBS rgbOffsets alphaOffset pixelPart imageSizeBSconstructBitmapStringFormattedbitmapFmtBGR24A4VRbitmapFmtRGB24A4VRbitmapFmtRGB24A4bitmapFmtRGB32encodeBSFormatencodeIBF_BGR24A4VR'encodeIBF_RGB24A4VR'encodeIBF_RGB24A4'encodeIBF_RGB32' tryBSFormattryIBF_BGR24A4VR'tryIBF_RGB24A4VR'tryIBF_RGB24A4' tryIBF_RGB32'BitmapStringRGB24A4VRBitmapImageString_polyval_bitmapImageStringbitmapStringBytesPerRow widthPadding bytesPerRow imageSizeBitmapStringRGB32handlers++ maybeReadbyteLenslgetterlsetter$fConvPixelBGRAPixelBGRA$fConvPixelBGRAPixelRGBA$fConvPixelBGRAPixelBGR$fConvPixelBGRAPixelRGB$fConvPixelRGBAPixelBGRA$fConvPixelRGBAPixelRGBA$fConvPixelRGBAPixelBGR$fConvPixelRGBAPixelRGB$fConvPixelBGRPixelBGRA$fConvPixelBGRPixelRGBA$fConvPixelBGRPixelBGR$fConvPixelBGRPixelRGB$fConvPixelRGBPixelBGRA$fConvPixelRGBPixelRGBA$fConvPixelRGBPixelBGR$fConvPixelRGBPixelRGB$fPixelPixelBGRA$fPixelPixelRGBA$fPixelPixelBGR$fPixelPixelRGBbase Data.MaybeNothingghc-prim GHC.TypesFalse serializeFmt$fShowBitmapArray$fBitmapBitmapArray$fBitmapCroppablea$fBitmapReflectablea$fBitmapBitmapForeignTrueGHC.BasefoldrJust$fBitmapSearchablea$fBitmapBitmapFunctionGHC.Err undefined$fBitmapCroppableBitmapString$fBitmapReflectableBitmapString$fBitmapBitmapString$fSerializeBitmapString$fBinaryBitmapString$fEqBitmapImageString($fBitmapReflectableBitmapStringRGB24A4VR'$fBitmapSearchableBitmapStringRGB24A4VR$fBitmapBitmapStringRGB24A4VR $fSerializeBitmapStringRGB24A4VR$fBinaryBitmapStringRGB24A4VR$$fBitmapReflectableBitmapStringRGB32#$fBitmapSearchableBitmapStringRGB32$fBitmapBitmapStringRGB32$fSerializeBitmapStringRGB32$fBinaryBitmapStringRGB32