3 This is barcode.info, produced by makeinfo version 4.0b from
6 This file is the User's Manual for the barcode library (version
16 The "barcode" package is mainly a C library for creating bar-code
17 output files. It also includes a command line front-end and (in a
18 foreseeable future) a graphic frontend.
20 The package is designed as a library because we think the main use
21 for barcode-generation tools is inside more featured applications. The
22 library addresses bar code printing as two distinct problems: creation
23 of bar information and actual conversion to an output format. To this
24 aim we use an intermediate representation for bar codes, which is
25 currently documented in the `ps.c' source file (not in this document).
27 Note that the library and the accompanying material is released
28 according to the GPL license, not the LGPL one. A copy of the GPL is
29 included in the distribution tarball.
34 *Node: The Barcode Object
35 The Underlying Data Structure
36 *****************************
38 Every barcode-related function acts on a data structure defined in
39 the `barcode.h' header, which must be included by any C source file
40 that uses the library. The header is installed by make install.
42 The definition of the data structure is included here for reference:
45 int flags; /* type of encoding and other flags */
46 char *ascii; /* malloced */
47 char *partial; /* malloced too */
48 char *textinfo; /* information about text placement */
49 char *encoding; /* code name, filled by encoding engine */
50 int width, height; /* output units */
51 int xoff, yoff; /* output units */
52 int margin; /* output units */
53 double scalef; /* requested scaling for barcode */
54 int error; /* an errno-like value, in case of failure */
57 The exact meaning of each field and the various flags implemented are
58 described in the following sections.
60 Even though you won't usually need to act on the contents of this
61 structure, some of the functions in the library receive arguments that
62 are directly related to one or more of these fields.
72 The flags are, as you may suspect, meant to specify the exact
73 behaviour of the library. They are often passed as an argument to
74 barcode functions and are discussed in the next section.
80 These fields are internally managed by the library, and you are
81 not expected to touch them if you use the provided API. All of
82 them are allocated with malloc.
86 They specify the width and height of the active barcode region
87 (i.e., excluding the white margin), in the units used to create
88 output data (for postscript they are points, 1/72th of an inch,
89 0.352 mm). The fields can be either assigned to in the structure
90 or via Barcode_Position(), at your choice. If either value or
91 both are left to their default value of zero, the output engine
92 will assign default values according to the specified scaling
93 factor. If the specified width is bigger than needed (according to
94 the scaling factor), the output barcode will be centered in its
95 requested region. If either the width of the height are too small
96 for the specified scale factor, the output bar code will expand
97 symmetrically around the requested region.
101 The fields specify offset from the coordinate origin of the output
102 engine (for postscript, position 0,0 is the lower left corner of
103 the page). The fields can be either assigned to in the structure
104 or via Barcode_Position(), at your choice. The offset specifies
105 where the white margin begins, not where the first bar will be
106 printed. To print real ink to the specified position you should
110 The white margin that will be left around the printed area of the
111 bar code. The same margin is applied to all sides of the printed
112 area. The default value for the margin is defined in `barcode.h'
113 as BARCODE_DEFAULT_MARGIN (10).
116 The enlarge or shrink value for the bar code over its default
117 dimension. The width and scalef fields interact deeply in the
118 creation of the output, and a complete description of the issues
119 appears later in this section.
122 The field is used when a barcode function fails to host an
123 errno-like integer value.
125 Use of the width and scalef fields.
126 -----------------------------------
128 A width unit is the width of the thinnest bar and/or space in the
129 chosen code; it defaults to 1 point if the output is postscript or
130 encapsulated postscript.
132 Either or both the code width and the scale factor can be left
133 unspecified (i.e., zero). The library deals with defaults in the
137 If both the width and the scale factor are unspecified, the scale
138 factor will default to 1.0 and the width is calculated according
139 to the actual width of the bar code being printed.
142 If the width is not specified, it is calculated according to the
145 Scale factor unspecified
146 If the scale factor is not specified, it will be chosen so that
147 the generated bar code exactly fits the specified width.
150 The code will be printed inside the specified region according to
151 the specified scale factor. It will be aligned to the left. If,
152 however, the chosen width is too small for the specific bar code
153 and scaling factor, then the code will extend symmetrically to the
154 left and to the right of the chosen region.
159 *Node: The Intermediate Representation
160 The Intermediate Representation
161 ===============================
163 The encoding functions print their output into the partial and
164 texinfo fields of the barcode data structure. Those fields, together
165 with position information, are then used to generate actual output.
166 This is an informal description of the intermediate format.
168 The first char in partial tells how much extra space to add to the
169 left of the bars. For EAN-13, it is used to leave space to print the
170 first digit, other codes may have '0' for no-extra-space-needed.
172 The next characters are alternating bars and spaces, as multiples of
173 the base dimension which is 1 unless the code is rescaled. Rescaling is
174 calculated as the ratio from the requested width and the calculated
175 width. Digits represent bar/space dimensions. Lower-case letters
176 represent those bars that should extend lower than the others: 'a' is
177 equivalent to '1', 'b' is '2' and so on up to 'i' which is equivalent to
178 '9'. Other letters will be used for encoding-specific meanings, as soon
181 The textinfo string is made up of fields %lf:%lf:%c separated by
182 blank space. The first integer is the x position of the character, the
183 second is the font size (before rescaling) and the char item is the
184 character to be printed.
186 Both the partial and textinfo strings may include "-" or "+" as
187 special characters (in textinfo the char should be a stand-alone word).
188 They state where the text should be printed: below the bars ("-",
189 default) or above the bars. This is used, for example, to print the
190 add-5 and add-2 codes to the right of UPC or EAN codes (the add-5
191 extension is mostly used in ISBN codes).
196 *Node: Supported Flags
200 The following flags are supported by version 0.98 of the library:
202 `BARCODE_ENCODING_MASK'
203 The mask is used to extract the encoding-type identifier from the
219 The currently supported encoding types: EAN (13 digits, 8 digits,
220 13 + 2 add-on and 13 + 5 add-on), UPC (UPC-A, UPC-E, UPC-A with 2
221 or 5 digit add-on), ISBN (with or without the 5-digit add-on),
222 CODE128-B (the whole set of printable ASCII characters), CODE128-C
223 (two digits encoded by each barcode symbol), CODE128 (all ASCII
224 values), a "raw-input" pseudo-code that generates CODE128 output,
225 CODE39 (alphanumeric), "interleaved 2 of 5" (numeric), Codabar
226 (numeric plus a few symbols), MSI (numeric) and Plessey (hex
227 digits). *Note Supported Encodings::.
230 This special encoding type (represented by a value of zero, so it
231 will be the default) tells the encoding procedure to look for the
232 first encoding type that can deal with a textual string.
233 Therefore, a 11-digit code will be printed as UPC (as well as
234 6-digit, 11+2 and 11+5), a 12-digit (or 7-digit, or 12+2 or 12+5)
235 as EAN13, an ISBN code (with or without hyphens, with or without
236 add-5) will be encoded in its EAN13 representation, an even number
237 of digits is encoded using CODE128C and a generic string is
238 encoded using CODE128B. Since code-39 offers a much larger
239 representation for the same text string, code128-b is preferred
240 over code39 for alphanumeric strings.
243 Instructs the engine not to print the ascii string on output. By
244 default the bar code is accompanied with an ascii version of the
247 `BARCODE_NO_CHECKSUM'
248 Instructs the engine not to add the checksum character to the
249 output. Not all the encoding types can drop the checksum; those
250 where the checksum is mandatory (like EAN and UPC) just ignore the
253 `BARCODE_OUTPUT_MASK'
254 The mask is used to extract the output-type identifier from the
260 `BARCODE_OUT_PCL_III'
261 The currently supported encoding types: full-page postscript and
262 encapsulated postscript; PCL (print command language, for HP
263 printers) and PCL-III (same as PCL, but uses a font not available
266 `BARCODE_OUT_NOHEADERS'
267 The flag instructs the printing engine not to print the header and
268 footer part of the file. This makes sense for the postscript
269 engine but might not make sense for other engines; such other
270 engines will silently ignore the flag just like the PCL back-end
277 Functions Exported by the Library
278 *********************************
280 The functions included in the barcode library are declared in the
281 header file barcode.h. They perform the following tasks:
283 `struct Barcode_Item *Barcode_Create(char *text);'
284 The function creates a new barcode object to deal with a specified
285 text string. It returns NULL in case of failure and a pointer to
286 a barcode data structure in case of success.
288 `int Barcode_Delete(struct Barcode_Item *bc);'
289 Destroy a barcode object. Always returns 0 (success)
291 `int Barcode_Encode(struct Barcode_Item *bc, int flags);'
292 Encode the text included in the bc object. Valid flags are the
293 encoding type (other flags are ignored) and BARCODE_NO_CHECKSUM
294 (other flags are silently ignored); if the flag argument is zero,
295 bc->flags will apply. The function returns 0 on success and -1 in
296 case of error. After successful termination the data structure
297 will host the description of the bar code and its textual
298 representation, after a failure the error field will include the
299 reason of the failure.
301 `int Barcode_Print(struct Barcode_Item *bc, FILE *f, int flags);'
302 Print the bar code described by bc to the specified file. Valid
303 flags are the output type, BARCODE_NO_ASCII and
304 BARCODE_OUT_NOHEADERS, other flags are ignored. If any of these
305 flags is zero, it will be inherited from bc->flags which therefore
306 takes precedence. The function returns 0 on success and -1 in case
307 of error (with bc->error set accordingly). In case of success, the
308 bar code is printed to the specified file, which won't be closed
311 `int Barcode_Position(struct Barcode_Item *bc, int wid, int hei, int xoff, int yoff, double scalef);'
312 The function is a shortcut to assign values to the data structure.
314 `int Barcode_Encode_and_Print(char *text, FILE *f, int wid, int hei, int xoff, int yoff, int flags);'
315 The function deals with the whole life of the barcode object by
316 calling the other functions; it uses all the specified flags.
318 `int Barcode_Version(char *versionname);'
319 Returns the current version as an integer number of the form major
320 * 10000 + minor * 100 + release. Therefore, version 1.03.5 will be
321 returned as 10305 and version 0.53 as 5300. If the argument is
322 non-null, it will be used to return the version number as a
323 string. Note that the same information is available from two
324 preprocessor macros: BARCODE_VERSION (the string) and
325 BARCODE_VERSION_INT (the integer number).
330 *Node: The barcode Executable
331 The barcode frontend program
332 ****************************
334 The barcode program is a front-end to access some features of the
335 library from the command line. It is able to read user supplied
336 strings from the command line or a data file (standard input by default)
337 and encode all of them.
342 *Node: The Command Line
346 barcode accepts the following options:
349 Print a usage summary and exit.
352 Identify a file where strings to be encoded are read from. If
353 missing (and if -b is not used) it defaults to standard input.
354 Each data line of the input file will be used to create one
358 Output file. It defaults to standard output.
361 Specify a single "barcode" string to be encoded. The option can
362 be used multiple times in order to encode multiple strings (this
363 will result in multi-page postscript output or a table of barcodes
364 if -t is specified). The strings must match the encoding chosen;
365 if it doesn't match the program will print a warning to stderr and
366 generate "blank" output (although not zero-length). Please note
367 that a string including spaces or other special characters must be
371 encoding is the name of the chosen encoding format being used. It
372 defaults to the value of the environment variable BARCODE_ENCODING
373 or to auto detection if the environment is also unset.
376 The geometry argument is of the form "[<width> x <height>] [+
377 <xmargin> + <ymargin>]" (with no intervening spaces). Unspecified
378 margin values will result in no margin; unspecified size results
379 in default size. The specified values represent print points by
380 default, and can be inches, millimeters or other units according
381 to the -u option or the BARCODE_UNIT environment variable. The
382 argument is used to place the printout code on the page. Note that
383 an additional white margin of 10 points is added to the printout.
384 If the option is unspecified, BARCODE_GEOMETRY is looked up in the
385 environment, if missing a default size and no margin (but the
386 default 10 points) are used.
389 Used to print several barcodes to a single page, this option is
390 meant to be used to print stickers. The argument is of the form
391 "<columns> x <lines> [+ <leftmargin> + <bottommargin> [-
392 <rightmargin> [- <topmargin>]]]" (with no intervening spaces); if
393 missing, the top and right margin will default to be the same as
394 the bottom and left margin. The margins are specified in print
395 points or in the chosen unit (see -u below). If the option is not
396 specified, BARCODE_TABLE is looked up in the environment,
397 otherwise no table is printed and each barcode will get its own
398 page. The size (but not the position) of a barcode item within a
399 table can also be selected using -g (see "geometry" above),
400 without struggling with external and internal margins. I still
401 think management of geometries in a table is suboptimal, but I
402 can't make it better without introducing incompatibilities.
405 Specifies an internal margin for each sticker in the table. The
406 argument is of the form "<xmargin>,<ymargin>" and the margin is
407 applied symmetrically to the sticker. If unspecified, the
408 environment variable BARCODE_MARGIN is used or a default internal
409 margin of 10 points is used.
412 "Numeric" output: don't print the ASCII form of the code, only the
416 No checksum character (for encodings that allow it, like code 39,
417 other codes, like UPC or EAN, ignore this option).
420 Encapsulated postscript (default is normal postscript). When the
421 output is generated as EPS only one barcode is encoded.
424 PCL output. Please note that the Y direction goes from top to
425 bottom for PCL, and the origin for an image is the top-left corner
426 instead of the bottom-left
429 Specify a non-default page size. The page size can be specified in
430 millimeters, inches or plain numbers (for example: "210x297mm",
431 "8.5x11in", "595x842"). A page specification as numbers will be
432 interpreted according to the current unit specification (see -u
433 below). If libpaper is available, you can also specify the page
434 size with its name, like "A3" or "letter" (libpaper is a standard
435 component of Debian GNU/Linux, but may be missing elsewhere). The
436 default page size is your system-wide default if libpaper is
440 Choose the unit used in size specifications. Accepted values are
441 "mm", "cm", "in" and "pt". By default, the program will check
442 BARCODE_UNIT in the environment, and assume points otherwise (this
443 behaviour is compatible with 0.92 and previous versions. If -u
444 appears more than once, each instance will modified the behaviour
445 for the arguments at its right, as the command line is processes
446 left to right. The program internally works with points, and any
447 size is approximated to the nearest multiple of one point. The -u
448 option affect -g (geometry), -t (table) and -p (page size).
453 *Node: Supported Encodings
457 The program encodes text strings passed either on the command line
458 (with -b) or retrieved from standard input. The text representation is
459 interpreted according to the following rules. When auto-detection of
460 the encoding is enabled (i.e, no explicit encoding type is specified),
461 the encoding types are scanned to find one that can digest the text
462 string. The following list of supported types is sorted in the same
463 order the library uses when auto-detecting a suitable encoding for a
467 The EAN frontend is similar to UPC; it accepts strings of digits,
468 12 or 7 characters long. Strings of 13 or 8 characters are
469 accepted if the provided checksum digit is correct. I expect most
470 users to feed input without a checksum, though. The add-2 and
471 add-5 extension are accepted for both the EAN-13 and the EAN-8
472 encodings. The following are example of valid input strings:
473 "123456789012" (EAN-13), "1234567890128" (EAN-13 wih checksum),
474 "1234567" (EAN-8), "12345670 12345" (EAN-8 with checksum and
475 add-5), "123456789012 12" (EAN-13 with add-2), "123456789012
476 12345" (EAN-13 with add-5).
479 The UPC frontend accepts only strings made up of digits (and, if a
480 supplemental encoding is used, a blank to separate it). It
481 accepts strings of 11 or 12 digits (UPC-A) and 6 or 7 or 8 digits
484 The 12th digit of UPC-A is the checksum and is added by the
485 library if not specified in the input; if it is specified, it must
486 be the right checksum or the code is rejected as invalid. For
487 UPC-E, 6 digit are considered to be the middle part of the code, a
488 leading 0 is assumed and the checksum is added; 7 digits are
489 either considered the initial part (leading digit 0 or 1, checksum
490 missing) or the final part (checksum specified, leading 0
491 assumed); 8 digits are considered to be the complete code, with
492 leading 0 or 1 and checksum. For both UPC-A and UPC-E, a trailing
493 string of 2 digits or 5 digits is accepted as well. Therefore, the
494 following are examples of valid strings that can be encoded as UPC:
495 "01234567890" (UPC-A) "012345678905" (UPC-A with checksum),
496 "012345" (UPC-E), "01234567890 12" (UPC-A, add-2) and "01234567890
497 12345" (UPC-A, add-5), "0123456 12" (UPC-E, add-2). Please note
498 that when setting BARCODE_ANY to auto-detect the encoding to be
499 used, 12-digit strings and 7-digit strings will always be
500 identified as EAN. This because I expect most user to provide
501 input without a checksum. If you need to specify UPC-with-checksum
502 as input you must explicitly set BARCODE_UPC as a flag or use -e
503 upc on the command line.
506 ISBN numbers are encoded as EAN-13 symbols, with an optional add-5
507 trailer. The ISBN frontend of the library accepts real ISBN
508 numbers and deals with any hyphen and, if present, the ISBN
509 checksum character before encoding data. Valid representations for
510 ISBN strings are for example: "1-56592-292-1", "3-89721-122-X" and
511 "3-89721-122-X 06900".
514 This encoding can represent all of the printing ASCII characters,
515 from the space (32) to DEL (127). The checksum digit is mandatory
519 The "C" variation of Code-128 uses Code-128 symbols to represent
520 two digits at a time (Code-128 is made up of 104 symbols whose
521 interpretation is controlled by the start symbol being used). Code
522 128-C is thus the most compact way to represent any even number of
523 digits. The encoder refuses to deal with an odd number of digits
524 because the caller is expected to provide proper padding to an
525 even number of digits. (Since Code-128 includes control symbols to
526 switch charset, it is theoretically possible to represent the odd
527 digit as a Code 128-A or 128-B symbol, but this tool doesn't
528 currently implement this option).
531 Code-128 output represented symbol-by-symbol in the input string.
532 To override part of the problems outlined below in specifying
533 code128 symbols, this pseudo-encoding allows the used to specify a
534 list of code128 symbols separated by spaces. Each symbol is
535 represented by a number in the range 0-105. The list should
536 include the leading character.The checksum and the stop character
537 are automatically added by the library. Most likely this
538 pseudo-encoding will be used with BARCODE_NO_ASCII and some
539 external program to supply the printed text.
542 The code-39 standard can encode uppercase letters, digits, the
543 blank space, plus, minus, dot, star, dollar, slash, percent. Any
544 string that is only composed of such characters is accepted by the
545 code-39 encoder. To avoid loosing information, the encoder refuses
546 to encode mixed-case strings (a lowercase string is nonetheless
547 accepted as a shortcut, but is encoded as uppercase).
550 This encoding can only represent an even number of digits (odd
551 digits are represented by bars, and even digits by the
552 interleaving spaces). The name stresses the fact that two of the
553 five items (bars or spaces) allocated to each symbol are wide,
554 while the rest are narrow. The checksum digit is optional (can be
555 disabled via BARCODE_NO_CHECKSUM). Since the number of digits,
556 including the checksum, must be even, a leading zero is inserted
557 in the string being encoded if needed (this is specifically stated
558 in the specs I have access to).
561 Automatic selection between alphabet A, B and C of the Code-128
562 standard. This encoding can represent all ASCII symbols, from 0
563 (NUL) to 127 (DEL), as well as four special symbols, named F1, F2,
564 F3, F4. The set of symbols available in this encoding is not
565 easily represented as input to the barcode library, so the
566 following convention is used. In the input string, which is a
567 C-language null-terminated string, the NUL char is represented by
568 the value 128 (0x80, 0200) and the F1-F4 characters are
569 represented by the values 193-196 (0xc1-0xc4, 0301-0304). The
570 values have been chosen to ease their representation as escape
573 Since the shell doesn't seem to interpret escape sequences on the
574 command line, the "-b" option cannot be easily used to designate
575 the strings to be encoded. As a workaround you can resort to the
576 command echo, either within back-ticks or used separately to
577 create a file that is then fed to the standard-input of barcode -
578 assuming your echo command processes escape sequences. The
579 newline character is especially though to encode (but not
580 impossible unless you use a csh variant.
582 These problems only apply to the command-line tool; the use of
583 library functions doesn't give any problem. In needed, you can use
584 the "code 128 raw" pseudo-encoding to represent code128 symbols by
585 their numerical value. This encoding is used late in the
586 auto-selection mechanism because (almost) any input string can be
587 represented using code128.
590 Codabar can encode the ten digits and a few special symbols
591 (minus, plus, dollar, colon, bar, dot). The characters "A", "B",
592 "C" and "D" are used to represent four different start/stop
593 characters. The input string to the barcode library can include
594 the start and stop characters or not include them (in which case
595 "A" is used as start and "B" as stop). Start and stop characters
596 in the input string can be either all lowercase or all uppercase
597 and are always printed as uppercase.
600 Plessey barcodes can encode all the hexadecimal digits. Alphabetic
601 digits in the input string must either be all lowercase or all
602 uppercase. The output text is always uppercase.
605 MSI can only encode the decimal digits. While the standard
606 specifies either one or two check digits, the current
607 implementation in this library only generates one check digit.
610 The code-93 standard can natively encode 48 different characters,
611 including uppercase letters, digits, the blank space, plus, minus,
612 dot, star, dollar, slash, percent, as well as five special
613 characters: a start/stop delimiter and four "shift characters"
614 used for extended encoding. Using this "extended encoding"
615 method, any standard 7-bit ASCII character can be encoded, but it
616 takes up two symbol lengths in barcode if the character is not
617 natively supported (one of the 48). The encoder here fully
618 implements the code 93 encoding standard. Any characters natively
619 supported (A-Z, 0-9, ".+-/$&%") will be encoded as such - for any
620 other characters (such as lower case letters, brackets,
621 parentheses, etc.), the encoder will revert to extended encoding.
622 As a note, the option to exclude the checksum will eliminate the
623 two modulo-47 checksums (called C and K) from the barcode, but this
624 probably will make it unreadable by 99% of all scanning systems.
625 These checksums are specified to be used at the firmware level,
626 and their absence will be interpreted as an invalid barcode.
635 While the default output is Postscript (possibly EPS), and Postscript
636 can be post-processed to almost anything, it is sometimes desirable to
637 create output directly usable by the specific printer at hand. PCL is
638 currently supported as an output format for this reason. Please note
639 that the Y coordinate for PCL goes from top to bottom, while for
640 Postscript it goes from bottom to top. Consistently, while in
641 Postscript you specify the bottom-left corner as origin, for PCL you
642 specify the top-left corner.
644 Barcode output for PCL Printers (HP LaserJet and compatibles), was
645 developed using PCL5 Reference manuals from HP. that really refers to
647 * LaserJet III, III P, III D, III Si,
657 * DeskJet 1200 and 1600.
660 However, barcode printing uses a very small subset of PCL, probably
661 also LaserJet II should print it without problem, but the resulting
662 text may be horrible.
664 The only real difference from one printer to another really depends
665 on which font are available in the printer, used in printing the label
666 associated to the bars (if requested).
668 Earlier LaserJet supports only bitmaps fonts, so these are not
669 "scalable". (Ljet II ?), Also these fonts, when available, have a
670 specified direction, and not all of them are available in both Portrait
673 From LaserJet 4 series, (except 4L/5L that are entry-level printers),
674 Arial scalable font should be available, so it's the "default font"
675 used by this program.
677 LaserJet III series printers (and 4L, 5L), don't feature "Arial" as a
678 resident font, so you should use BARCODE_OUT_PCL_III instead of
679 BARCODE_OUT_PCL., and font the font used will be "Univers" instead of
682 Results on compatible printers, may depend on consistency of PCL5
683 compatibility, in doubt, try BARCODE_OUT_PCL_III
685 PJL commands are not used here, as it's not very compatible.
692 * Epson N-1200 emul PCL
694 * Toshiba DP2570 (copier) + PCL option
696 * Epson EPL-7100 emul. HP LaserJet II: bars print fine but text is
702 *Node: Bugs and Pending Issues
703 Bugs and Pending Issues.
704 ************************
706 The current management of borders/margins is far from optimal. The
707 "default" margin applied by the library interferes with the external
708 representation, but I feel it is mandatory to avoid creating barcode
709 output with no surrounding white space (the problem is especially
710 relevant for EPS output).
712 EAN-128 is not (yet) supported. I plan to implement it pretty soon
713 and then bless the package as version 1.0.
719 Tag Table:Node: Top
\7f154
721 Node: The Barcode Object
\7f1404
722 Node: The Field List
\7f2821
723 Node: The Intermediate Representation
\7f6586
724 Node: Supported Flags
\7f8359
725 Node: The API
\7f11343
726 Node: The barcode Executable
\7f14029
727 Node: The Command Line
\7f14458
728 Node: Supported Encodings
\7f19557
729 Node: PCL Output
\7f28997
730 Node: Bugs and Pending Issues
\7f31316