Merge branch 'master' of http://119.23.72.7/sunlong_v5/note-library

config/barcode.php

+<?php
+/**
+ * Created by PhpStorm.
+ * User: ICHUNT
+ * Date: 2020/5/9
+ * Time: 16:02
+ */
+
+
+return [
+
+    'store_path' => public_path(),
+];
\ No newline at end of file

vendor/milon/barcode/.gitignore

+/vendor
+composer.phar
+composer.lock
+.DS_Store
+.idea
\ No newline at end of file

vendor/milon/barcode/.travis.yml

+language: php
+
+php: 
+  - 5.3
+  - 5.4
+  - 5.5
+
+before_script:
+  - curl -s http://getcomposer.org/installer | php
+  - php composer.phar install --dev
+
+script: phpunit
\ No newline at end of file

vendor/milon/barcode/LICENSE.TXT

+**********************************************************************
+* TCPDF LICENSE
+**********************************************************************
+
+  TCPDF is free software: you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as
+  published by the Free Software Foundation, either version 3 of the
+  License, or (at your option) any later version.
+
+**********************************************************************
+**********************************************************************
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+**********************************************************************
+**********************************************************************
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
+**********************************************************************
+**********************************************************************

vendor/milon/barcode/composer.json

+{
+    "name": "milon/barcode",
+
+    "description": "Barcode generator like Qr Code , PDF417,C39, C39+,C39E,C39E+,C93,S25,S25+,I25,I25+,C128,C128A,C128B,C128C,2-Digits UPC-Based Extention,5-Digits UPC-Based Extention,EAN 8,EAN 13,UPC-A,UPC-E,MSI (Variation of Plessey code) ",
+    "keywords": ["barcode", "laravel","qrcode","QR Code","PDF417","Datamatrix","CODE 39","CODE 128","EAN","CODABAR"],
+    "license": "LGPL-3.0",
+    "authors": [
+    {
+        "name": "Nuruzzaman Milon",
+        "email": "contact@milon.im"
+    }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/support": "5.*"
+    },
+    "autoload": {
+        "psr-0": {
+            "Milon\\Barcode": "src/"
+        }
+    },
+    "minimum-stability": "stable"
+}

vendor/milon/barcode/phpunit.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+>
+    <testsuites>
+        <testsuite name="Package Test Suite">
+            <directory suffix=".php">./tests/</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>
\ No newline at end of file

vendor/milon/barcode/readme.md

+This is a barcode generation package inspired by [https://github.com/tecnickcom/TCPDF](https://github.com/tecnickcom/TCPDF). Actually I use that package's underline classes for generating barcode. This package is just a wrapper of that package and adds compatibility with Laravel 5.
+
+I used the following classes of that package.
+
+- src/Milon/Barcode/Datamatrix.php (include/barcodes/datamatrix.php)
+- src/Milon/Barcode/DNS1D.php (tcpdf_barcodes_1d.php)
+- src/Milon/Barcode/DNS2D.php (tcpdf_barcodes_2d.php)
+- src/Milon/Barcode/PDF417.php (include/barcodes/pdf417.php)
+- src/Milon/Barcode/QRcode.php (include/barcodes/qrcode.php)
+
+[Read More on TCPDF website](http://www.tcpdf.org)
+
+### This package is compatible with Laravel 5.2
+
+## Installation
+
+Begin by installing this package through Composer. Just run following command to terminal-
+
+```
+composer require milon/barcode
+```
+
+You can also edit your project's `composer.json` file to require `milon/barcode`.
+
+    "require": {
+		...
+		"milon/barcode": "^5.2"
+	}
+
+For Laravel 5.0 and 5.1 use this-
+
+    "require": {
+        ...
+        "milon/barcode": "^5.1"
+    }
+
+For Laravel 4.0, 4.1 and 4.2 use this-
+
+    "require": {
+        ...
+        "milon/barcode": "^4.2"
+    }
+
+Next, update Composer from the Terminal:
+
+    composer update
+
+Once this operation completes, the final step is to add the service provider. Open `config/app.php`, and add a new item to the providers array.
+
+```php
+'providers' => [
+    ...
+    Milon\Barcode\BarcodeServiceProvider::class,
+    ...
+]
+```
+
+For version 4.* add these lines on `app/config/app.php` file-
+
+```php
+'providers' => array(
+    ...
+    'Milon\Barcode\BarcodeServiceProvider',
+)
+```
+
+If you want to change Bar-code's settings (Store Path etc.), you need to publish its config file(s). For that you need to run in the terminal-
+
+    php artisan vendor:publish
+
+Make sure you have write permission to the storage path. By default it sets to `/storage` folder.
+
+Now add the alias.
+
+```php
+'aliases' => [
+	...
+	'DNS1D' => Milon\Barcode\Facades\DNS1DFacade::class,
+	'DNS2D' => Milon\Barcode\Facades\DNS2DFacade::class,
+]
+```
+
+For version 4.2 alias will be like this-
+
+```php
+'aliases' => array(
+	...
+	'DNS1D' => 'Milon\Barcode\Facades\DNS1DFacade',
+	'DNS2D' => 'Milon\Barcode\Facades\DNS2DFacade',
+)
+```
+
+Bar-code generator like
+Qr Code,
+PDF417,
+C39,C39+,
+C39E,C39E+,
+C93,
+S25,S25+,
+I25,I25+,
+C128,C128A,C128B,C128C,
+2-Digits UPC-Based Extention,
+5-Digits UPC-Based Extention,
+EAN 8,EAN 13,
+UPC-A,UPC-E,
+MSI (Variation of Plessey code)
+
+generator in html, png embedded base64 code and SVG canvas
+
+```php
+echo DNS1D::getBarcodeSVG("4445645656", "PHARMA2T");
+echo DNS1D::getBarcodeHTML("4445645656", "PHARMA2T");
+echo '<img src="data:image/png,' . DNS1D::getBarcodePNG("4", "C39+") . '" alt="barcode"   />';
+echo DNS1D::getBarcodePNGPath("4445645656", "PHARMA2T");
+echo '<img src="data:image/png;base64,' . DNS1D::getBarcodePNG("4", "C39+") . '" alt="barcode"   />';
+```
+
+```php
+echo DNS1D::getBarcodeSVG("4445645656", "C39");
+echo DNS2D::getBarcodeHTML("4445645656", "QRCODE");
+echo DNS2D::getBarcodePNGPath("4445645656", "PDF417");
+echo DNS2D::getBarcodeSVG("4445645656", "DATAMATRIX");
+echo '<img src="data:image/png;base64,' . DNS2D::getBarcodePNG("4", "PDF417") . '" alt="barcode"   />';
+```
+
+## Width and Height example
+
+```php
+echo DNS1D::getBarcodeSVG("4445645656", "PHARMA2T",3,33);
+echo DNS1D::getBarcodeHTML("4445645656", "PHARMA2T",3,33);
+echo '<img src="' . DNS1D::getBarcodePNG("4", "C39+",3,33) . '" alt="barcode"   />';
+echo DNS1D::getBarcodePNGPath("4445645656", "PHARMA2T",3,33);
+echo '<img src="data:image/png;base64,' . DNS1D::getBarcodePNG("4", "C39+",3,33) . '" alt="barcode"   />';
+```
+
+## Color
+
+```php
+echo DNS1D::getBarcodeSVG("4445645656", "PHARMA2T",3,33,"green");
+echo DNS1D::getBarcodeHTML("4445645656", "PHARMA2T",3,33,"green");
+echo '<img src="' . DNS1D::getBarcodePNG("4", "C39+",3,33,array(1,1,1)) . '" alt="barcode"   />';
+echo DNS1D::getBarcodePNGPath("4445645656", "PHARMA2T",3,33,array(255,255,0));
+echo '<img src="data:image/png;base64,' . DNS1D::getBarcodePNG("4", "C39+",3,33,array(1,1,1)) . '" alt="barcode"   />';
+```
+
+## 2D Barcodes
+
+```php
+echo DNS2D::getBarcodeHTML("4445645656", "QRCODE");
+echo DNS2D::getBarcodePNGPath("4445645656", "PDF417");
+echo DNS2D::getBarcodeSVG("4445645656", "DATAMATRIX");
+```
+
+## 1D Barcodes
+
+```php
+echo DNS1D::getBarcodeHTML("4445645656", "C39");
+echo DNS1D::getBarcodeHTML("4445645656", "C39+");
+echo DNS1D::getBarcodeHTML("4445645656", "C39E");
+echo DNS1D::getBarcodeHTML("4445645656", "C39E+");
+echo DNS1D::getBarcodeHTML("4445645656", "C93");
+echo DNS1D::getBarcodeHTML("4445645656", "S25");
+echo DNS1D::getBarcodeHTML("4445645656", "S25+");
+echo DNS1D::getBarcodeHTML("4445645656", "I25");
+echo DNS1D::getBarcodeHTML("4445645656", "I25+");
+echo DNS1D::getBarcodeHTML("4445645656", "C128");
+echo DNS1D::getBarcodeHTML("4445645656", "C128A");
+echo DNS1D::getBarcodeHTML("4445645656", "C128B");
+echo DNS1D::getBarcodeHTML("4445645656", "C128C");
+echo DNS1D::getBarcodeHTML("44455656", "EAN2");
+echo DNS1D::getBarcodeHTML("4445656", "EAN5");
+echo DNS1D::getBarcodeHTML("4445", "EAN8");
+echo DNS1D::getBarcodeHTML("4445", "EAN13");
+echo DNS1D::getBarcodeHTML("4445645656", "UPCA");
+echo DNS1D::getBarcodeHTML("4445645656", "UPCE");
+echo DNS1D::getBarcodeHTML("4445645656", "MSI");
+echo DNS1D::getBarcodeHTML("4445645656", "MSI+");
+echo DNS1D::getBarcodeHTML("4445645656", "POSTNET");
+echo DNS1D::getBarcodeHTML("4445645656", "PLANET");
+echo DNS1D::getBarcodeHTML("4445645656", "RMS4CC");
+echo DNS1D::getBarcodeHTML("4445645656", "KIX");
+echo DNS1D::getBarcodeHTML("4445645656", "IMB");
+echo DNS1D::getBarcodeHTML("4445645656", "CODABAR");
+echo DNS1D::getBarcodeHTML("4445645656", "CODE11");
+echo DNS1D::getBarcodeHTML("4445645656", "PHARMA");
+echo DNS1D::getBarcodeHTML("4445645656", "PHARMA2T");
+```
+
+## License
+This package is published under `GNU LGPLv3` license and copyright to [Nuruzzaman Milon](http://milon.im). Original Barcode generation classes were written by Nicola Asuni. The license agreement is on project's root.
+
+License: GNU LGPLv3   
+Package Author: [Nuruzzaman Milon](http://milon.im)   
+Original Barcode Class Author: [Nicola Asuni](http://www.tcpdf.org)   
+Package Copyright: Nuruzzaman Milon   
+Barcode Generation Class Copyright:   
+Nicola Asuni   
+Tecnick.com LTD   
+www.tecnick.com   

vendor/milon/barcode/src/Milon/Barcode/BarcodeServiceProvider.php

+<?php 
+
+namespace Milon\Barcode;
+
+use Illuminate\Support\ServiceProvider;
+
+class BarcodeServiceProvider extends ServiceProvider {
+
+    /**
+     * Indicates if loading of the provider is deferred.
+     *
+     * @var bool
+     */
+    protected $defer = false;
+
+
+/**
+ * Publish asset
+ */
+	public function boot() {
+		$this->publishes([
+		 	 __DIR__.'/../../config/config.php' => config_path('barcode.php'),
+		]);
+	}
+
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register() {
+
+        $this->app->bind('DNS1D', function() {
+		return new DNS1D;
+	});
+	$this->app->bind('DNS2D', function() {
+		return new DNS2D;
+	});
+    }
+
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides() {
+        return array("DNS1D", "DNS2D");
+    }
+
+}

vendor/milon/barcode/src/Milon/Barcode/DNS2D.php

+<?php
+
+namespace Milon\Barcode;
+
+//============================================================+
+// File name   : tcpdf_barcodes_2d.php
+// Version     : 1.0.015
+// Begin       : 2009-04-07
+// Last Update : 2014-05-20
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2009-2014 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <http://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description : PHP class to creates array representations for
+//               2D barcodes to be used with TCPDF.
+//
+//============================================================+
+/**
+ * @file
+ * PHP class to creates array representations for 2D barcodes to be used with TCPDF.
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.015
+ */
+/**
+ * @class TCPDF2DBarcode
+ * PHP class to creates array representations for 2D barcodes to be used with TCPDF (http://www.tcpdf.org).
+ * @package com.tecnick.tcpdf
+ * @version 1.0.015
+ * @author Nicola Asuni
+ */
+
+use Milon\Barcode\QRcode;
+use Milon\Barcode\Datamatrix;
+use Milon\Barcode\PDF417;
+use Illuminate\Support\Str;
+
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/**
+ * Description of DNS2D
+ *
+ * @author dinesh
+ */
+class DNS2D {
+
+    /**
+     * Array representation of barcode.
+     * @protected
+     */
+    protected $barcode_array = false;
+
+    /**
+     * path to save png in getBarcodePNGPath
+     * @var <type>
+     */
+    protected $store_path;
+
+    /**
+     * Return a SVG string representation of barcode.
+     * <li>$arrcode['code'] code to be printed on text label</li>
+     * <li>$arrcode['num_rows'] required number of rows</li>
+     * <li>$arrcode['num_cols'] required number of columns</li>
+     * <li>$arrcode['bcode'][$r][$c] value of the cell is $r row and $c column (0 = transparent, 1 = black)</li></ul>
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parametrs are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+     * @param $w (int) Width of a single rectangle element in user units.
+     * @param $h (int) Height of a single rectangle element in user units.
+     * @param $color (string) Foreground color (in SVG format) for bar elements (background is transparent).
+     * @return string SVG code.
+     * @public
+     */
+    public function getBarcodeSVG($code, $type, $w = 3, $h = 3, $color = 'black') {
+        if (!$this->store_path) {
+            $this->setStorPath(\Config::get("barcode.store_path"));
+        }
+        //set barcode code and type
+        $this->setBarcode($code, $type);
+        // replace table for special characters
+        $repstr = array("\0" => '', '&' => '&amp;', '<' => '&lt;', '>' => '&gt;');
+        $svg = '<' . '?' . 'xml version="1.0" standalone="no"' . '?' . '>' . "\n";
+        $svg .= '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' . "\n";
+        $svg .= '<svg width="' . round(($this->barcode_array['num_cols'] * $w), 3) . '" height="' . round(($this->barcode_array['num_rows'] * $h), 3) . '" version="1.1" xmlns="http://www.w3.org/2000/svg">' . "\n";
+        $svg .= "\t" . '<desc>' . strtr($this->barcode_array['code'], $repstr) . '</desc>' . "\n";
+        $svg .= "\t" . '<g id="elements" fill="' . $color . '" stroke="none">' . "\n";
+        // print barcode elements
+        $y = 0;
+        // for each row
+        for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+            $x = 0;
+            // for each column
+            for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+                if ($this->barcode_array['bcode'][$r][$c] == 1) {
+                    // draw a single barcode cell
+                    $svg .= "\t\t" . '<rect x="' . $x . '" y="' . $y . '" width="' . $w . '" height="' . $h . '" />' . "\n";
+                }
+                $x += $w;
+            }
+            $y += $h;
+        }
+        $svg .= "\t" . '</g>' . "\n";
+        $svg .= '</svg>' . "\n";
+        return $svg;
+    }
+
+    /**
+     * Return an HTML representation of barcode.
+     * <li>$arrcode['code'] code to be printed on text label</li>
+     * <li>$arrcode['num_rows'] required number of rows</li>
+     * <li>$arrcode['num_cols'] required number of columns</li>
+     * <li>$arrcode['bcode'][$r][$c] value of the cell is $r row and $c column (0 = transparent, 1 = black)</li></ul>
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parametrs are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+     * @param $w (int) Width of a single rectangle element in pixels.
+     * @param $h (int) Height of a single rectangle element in pixels.
+     * @param $color (string) Foreground color for bar elements (background is transparent).
+     * @return string HTML code.
+     * @public
+     */
+    public function getBarcodeHTML($code, $type, $w = 10, $h = 10, $color = 'black') {
+        if (!$this->store_path) {
+            $this->setStorPath(\Config::get("barcode.store_path"));
+        }
+        //set barcode code and type
+        $this->setBarcode($code, $type);
+        dump($this->barcode_array);
+        $html = '<div style="font-size:0;position:relative;width:' . ($w * $this->barcode_array['num_cols']) . 'px;height:' . ($h * $this->barcode_array['num_rows']) . 'px;">' . "\n";
+        // print barcode elements
+        $y = 0;
+        // for each row
+        for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+            $x = 0;
+            // for each column
+            for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+                if ($this->barcode_array['bcode'][$r][$c] == 1) {
+                    // draw a single barcode cell
+                    $html .= '<div style="background-color:' . $color . ';width:' . $w . 'px;height:' . $h . 'px;position:absolute;left:' . $x . 'px;top:' . $y . 'px;">&nbsp;</div>' . "\n";
+                }
+                $x += $w;
+            }
+            $y += $h;
+        }
+        $html .= '</div>' . "\n";
+        return $html;
+    }
+
+    /**
+     * Return a PNG image representation of barcode (requires GD or Imagick library).
+     * <li>$arrcode['code'] code to be printed on text label</li>
+     * <li>$arrcode['num_rows'] required number of rows</li>
+     * <li>$arrcode['num_cols'] required number of columns</li>
+     * <li>$arrcode['bcode'][$r][$c] value of the cell is $r row and $c column (0 = transparent, 1 = black)</li></ul>
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parametrs are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+     * @param $w (int) Width of a single rectangle element in pixels.
+     * @param $h (int) Height of a single rectangle element in pixels.
+     * @param $color (array) RGB (0-255) foreground color for bar elements (background is transparent).
+     * @return path or false in case of error.
+     * @public
+     */
+    public function getBarcodePNG($code, $type, $w = 3, $h = 3, $color = array(0, 0, 0)) {
+        if (!$this->store_path) {
+            $this->setStorPath(\Config::get("barcode.store_path"));
+        }
+        //set barcode code and type
+        $this->setBarcode($code, $type);
+        // calculate image size
+        $width = ($this->barcode_array['num_cols'] * $w);
+        $height = ($this->barcode_array['num_rows'] * $h);
+        if (function_exists('imagecreate')) {
+            // GD library
+            $imagick = false;
+            $png = imagecreate($width, $height);
+            $bgcol = imagecolorallocate($png, 255, 255, 255);
+            imagecolortransparent($png, $bgcol);
+            $fgcol = imagecolorallocate($png, $color[0], $color[1], $color[2]);
+        } elseif (extension_loaded('imagick')) {
+            $imagick = true;
+            $bgcol = new \imagickpixel('rgb(255,255,255');
+            $fgcol = new \imagickpixel('rgb(' . $color[0] . ',' . $color[1] . ',' . $color[2] . ')');
+            $png = new \Imagick();
+            $png->newImage($width, $height, 'none', 'png');
+            $bar = new \imagickdraw();
+            $bar->setfillcolor($fgcol);
+        } else {
+            return false;
+        }
+        // print barcode elements
+        $y = 0;
+        // for each row
+        for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+            $x = 0;
+            // for each column
+            for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+                if ($this->barcode_array['bcode'][$r][$c] == 1) {
+                    // draw a single barcode cell
+                    if ($imagick) {
+                        $bar->rectangle($x, $y, ($x + $w), ($y + $h));
+                    } else {
+                        imagefilledrectangle($png, $x, $y, ($x + $w), ($y + $h), $fgcol);
+                    }
+                }
+                $x += $w;
+            }
+            $y += $h;
+        }
+        ob_start();
+        // get image out put
+
+        if ($imagick) {
+            $png->drawimage($bar);
+            echo $png;
+        } else {
+            imagepng($png);
+            imagedestroy($png);
+        }
+        $image = ob_get_clean();
+        $image = base64_encode($image);
+        //$image = 'data:image/png;base64,' . base64_encode($image);
+        return $image;
+    }
+
+    /**
+     * Return a .png file path which create in server
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>C39 : CODE 39 - ANSI MH10.8M-1983 - USD-3 - 3 of 9.</li><li>C39+ : CODE 39 with checksum</li><li>C39E : CODE 39 EXTENDED</li><li>C39E+ : CODE 39 EXTENDED + CHECKSUM</li><li>C93 : CODE 93 - USS-93</li><li>S25 : Standard 2 of 5</li><li>S25+ : Standard 2 of 5 + CHECKSUM</li><li>I25 : Interleaved 2 of 5</li><li>I25+ : Interleaved 2 of 5 + CHECKSUM</li><li>C128 : CODE 128</li><li>C128A : CODE 128 A</li><li>C128B : CODE 128 B</li><li>C128C : CODE 128 C</li><li>EAN2 : 2-Digits UPC-Based Extention</li><li>EAN5 : 5-Digits UPC-Based Extention</li><li>EAN8 : EAN 8</li><li>EAN13 : EAN 13</li><li>UPCA : UPC-A</li><li>UPCE : UPC-E</li><li>MSI : MSI (Variation of Plessey code)</li><li>MSI+ : MSI + CHECKSUM (modulo 11)</li><li>POSTNET : POSTNET</li><li>PLANET : PLANET</li><li>RMS4CC : RMS4CC (Royal Mail 4-state Customer Code) - CBC (Customer Bar Code)</li><li>KIX : KIX (Klant index - Customer index)</li><li>IMB: Intelligent Mail Barcode - Onecode - USPS-B-3200</li><li>CODABAR : CODABAR</li><li>CODE11 : CODE 11</li><li>PHARMA : PHARMACODE</li><li>PHARMA2T : PHARMACODE TWO-TRACKS</li></ul>
+     * @param $w (int) Width of a single bar element in pixels.
+     * @param $h (int) Height of a single bar element in pixels.
+     * @param $color (array) RGB (0-255) foreground color for bar elements (background is transparent).
+     * @return url or false in case of error.
+     * @public
+     */
+    public function getBarcodePNGUri($code, $type, $w = 3, $h = 3, $color = array(0, 0, 0)) {
+        return url($this->getBarcodePNGPath($code, $type, $w, $h, $color));
+    }
+
+    /**
+     * Return a .png file path which create in server
+     * <li>$arrcode['code'] code to be printed on text label</li>
+     * <li>$arrcode['num_rows'] required number of rows</li>
+     * <li>$arrcode['num_cols'] required number of columns</li>
+     * <li>$arrcode['bcode'][$r][$c] value of the cell is $r row and $c column (0 = transparent, 1 = black)</li></ul>
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parametrs are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+     * @param $w (int) Width of a single rectangle element in pixels.
+     * @param $h (int) Height of a single rectangle element in pixels.
+     * @param $color (array) RGB (0-255) foreground color for bar elements (background is transparent).
+     * @return path of image whice created
+     * @public
+     */
+    public function getBarcodePNGPath($code, $type, $w = 3, $h = 3, $color = array(0, 0, 0)) {
+        if (!$this->store_path) {
+            $this->setStorPath(\Config::get("barcode.store_path"));
+        }
+        //set barcode code and type
+        $this->setBarcode($code, $type);
+        // calculate image size
+        $width = ($this->barcode_array['num_cols'] * $w);
+        $height = ($this->barcode_array['num_rows'] * $h);
+        if (function_exists('imagecreate')) {
+            // GD library
+            $imagick = false;
+            $png = imagecreate($width, $height);
+            $bgcol = imagecolorallocate($png, 255, 255, 255);
+            imagecolortransparent($png, $bgcol);
+            $fgcol = imagecolorallocate($png, $color[0], $color[1], $color[2]);
+        } elseif (extension_loaded('imagick')) {
+            $imagick = true;
+            $bgcol = new imagickpixel('rgb(255,255,255');
+            $fgcol = new imagickpixel('rgb(' . $color[0] . ',' . $color[1] . ',' . $color[2] . ')');
+            $png = new Imagick();
+            $png->newImage($width, $height, 'none', 'png');
+            $bar = new imagickdraw();
+            $bar->setfillcolor($fgcol);
+        } else {
+            return false;
+        }
+        // print barcode elements
+        $y = 0;
+        // for each row
+        for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+            $x = 0;
+            // for each column
+            for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+                if ($this->barcode_array['bcode'][$r][$c] == 1) {
+                    // draw a single barcode cell
+                    if ($imagick) {
+                        $bar->rectangle($x, $y, ($x + $w), ($y + $h));
+                    } else {
+                        imagefilledrectangle($png, $x, $y, ($x + $w), ($y + $h), $fgcol);
+                    }
+                }
+                $x += $w;
+            }
+            $y += $h;
+        }
+        $file_name= Str::slug($code);
+        $save_file = $this->checkfile($this->store_path . $file_name . ".png");
+
+        if ($imagick) {
+            $png->drawimage($bar);
+            //echo $png;
+        }
+        if (ImagePng($png, $save_file)) {
+            imagedestroy($png);
+            return str_replace(public_path(), '', $save_file);
+        } else {
+            imagedestroy($png);
+            return $code;
+        }
+    }
+
+    /**
+     * Set the barcode.
+     * @param $code (string) code to print
+     * @param $type (string) type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parametrs are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+     * @return array
+     */
+    protected function setBarcode($code, $type) {
+        $mode = explode(',', $type);
+        $qrtype = strtoupper($mode[0]);
+        switch ($qrtype) {
+            case 'DATAMATRIX': { // DATAMATRIX (ISO/IEC 16022)
+                    $barcode = new Datamatrix($code);
+                    $this->barcode_array = $barcode->getBarcodeArray();
+                    $this->barcode_array['code'] = $code;
+                    break;
+                }
+            case 'PDF417': { // PDF417 (ISO/IEC 15438:2006)
+                    if (!isset($mode[1]) OR ($mode[1] === '')) {
+                        $aspectratio = 2; // default aspect ratio (width / height)
+                    } else {
+                        $aspectratio = floatval($mode[1]);
+                    }
+                    if (!isset($mode[2]) OR ($mode[2] === '')) {
+                        $ecl = -1; // default error correction level (auto)
+                    } else {
+                        $ecl = intval($mode[2]);
+                    }
+                    // set macro block
+                    $macro = array();
+                    if (isset($mode[3]) AND ($mode[3] !== '') AND isset($mode[4]) AND ($mode[4] !== '') AND isset($mode[5]) AND ($mode[5] !== '')) {
+                        $macro['segment_total'] = intval($mode[3]);
+                        $macro['segment_index'] = intval($mode[4]);
+                        $macro['file_id'] = strtr($mode[5], "\xff", ',');
+                        for ($i = 0; $i < 7; ++$i) {
+                            $o = $i + 6;
+                            if (isset($mode[$o]) AND ($mode[$o] !== '')) {
+                                // add option
+                                $macro['option_' . $i] = strtr($mode[$o], "\xff", ',');
+                            }
+                        }
+                    }
+                    $barcode = new PDF417($code, $ecl, $aspectratio, $macro);
+                    $this->barcode_array = $barcode->getBarcodeArray();
+                    $this->barcode_array['code'] = $code;
+                    break;
+                }
+            case 'QRCODE': { // QR-CODE
+                    if (!isset($mode[1]) OR (!in_array($mode[1], array('L', 'M', 'Q', 'H')))) {
+                        $mode[1] = 'L'; // Ddefault: Low error correction
+                    }
+                    $barcode = new QRcode($code, strtoupper($mode[1]));
+                    $this->barcode_array = $barcode->getBarcodeArray();
+                    $this->barcode_array['code'] = $code;
+                    break;
+                }
+            default: {
+                    $this->barcode_array = false;
+                }
+        }
+    }
+
+    /**
+     *
+     * @param type $path
+     * @return type
+     */
+    protected function checkfile($path) {
+        if (file_exists($path)) {
+            unlink($path);
+        }
+        return $path;
+    }
+
+    public function setStorPath($path) {
+        $this->store_path = $path;
+        return $this;
+    }
+
+}

vendor/milon/barcode/src/Milon/Barcode/Datamatrix.php

+<?php 
+
+namespace Milon\Barcode;
+
+//============================================================+
+// File name   : datamatrix.php
+// Version     : 1.0.008
+// Begin       : 2010-06-07
+// Last Update : 2014-05-06
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2010-2014  Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <http://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// DESCRIPTION :
+//
+// Class to create DataMatrix ECC 200 barcode arrays for TCPDF class.
+// DataMatrix (ISO/IEC 16022:2006) is a 2-dimensional bar code.
+//============================================================+
+/**
+* @file
+* Class to create DataMatrix ECC 200 barcode arrays for TCPDF class.
+* DataMatrix (ISO/IEC 16022:2006) is a 2-dimensional bar code.
+*
+* @package com.tecnick.tcpdf
+* @author Nicola Asuni
+* @version 1.0.008
+*/
+
+// custom definitions
+if (!defined('DATAMATRIXDEFS')) {
+
+    /**
+     * Indicate that definitions for this class are set
+     */
+    define('DATAMATRIXDEFS', true);
+
+    // -----------------------------------------------------
+} // end of custom definitions
+// #*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#
+
+
+/**
+ * ASCII encoding: ASCII character 0 to 127 (1 byte per CW)
+ */
+define('ENC_ASCII', 0);
+
+/**
+ * C40 encoding: Upper-case alphanumeric (3/2 bytes per CW)
+ */
+define('ENC_C40', 1);
+
+/**
+ * TEXT encoding: Lower-case alphanumeric (3/2 bytes per CW)
+ */
+define('ENC_TXT', 2);
+
+/**
+ * X12 encoding: ANSI X12 (3/2 byte per CW)
+ */
+define('ENC_X12', 3);
+
+/**
+ * EDIFACT encoding: ASCII character 32 to 94 (4/3 bytes per CW)
+ */
+define('ENC_EDF', 4);
+
+/**
+ * BASE 256 encoding: ASCII character 0 to 255 (1 byte per CW)
+ */
+define('ENC_BASE256', 5);
+
+/**
+ * ASCII extended encoding: ASCII character 128 to 255 (1/2 byte per CW)
+ */
+define('ENC_ASCII_EXT', 6);
+
+/**
+ * ASCII number encoding: ASCII digits (2 bytes per CW)
+ */
+define('ENC_ASCII_NUM', 7);
+
+class Datamatrix {
+
+    /**
+     * Barcode array to be returned which is readable by Dinesh Rabara
+     * @protected
+     */
+    protected $barcode_array = array();
+
+    /**
+     * Store last used encoding for data codewords.
+     * @protected
+     */
+    protected $last_enc = ENC_ASCII;
+
+    /**
+     * Table of Data Matrix ECC 200 Symbol Attributes:<ul>
+     * <li>total matrix rows (including finder pattern)</li>
+     * <li>total matrix cols (including finder pattern)</li>
+     * <li>total matrix rows (without finder pattern)</li>
+     * <li>total matrix cols (without finder pattern)</li>
+     * <li>region data rows (with finder pattern)</li>
+     * <li>region data col (with finder pattern)</li>
+     * <li>region data rows (without finder pattern)</li>
+     * <li>region data col (without finder pattern)</li>
+     * <li>horizontal regions</li>
+     * <li>vertical regions</li>
+     * <li>regions</li>
+     * <li>data codewords</li>
+     * <li>error codewords</li>
+     * <li>blocks</li>
+     * <li>data codewords per block</li>
+     * <li>error codewords per block</li>
+     * </ul>
+     * @protected
+     */
+    protected $symbattr = array(
+        // square form ---------------------------------------------------------------------------------------
+        array(0x00a, 0x00a, 0x008, 0x008, 0x00a, 0x00a, 0x008, 0x008, 0x001, 0x001, 0x001, 0x003, 0x005, 0x001, 0x003, 0x005), // 10x10
+        array(0x00c, 0x00c, 0x00a, 0x00a, 0x00c, 0x00c, 0x00a, 0x00a, 0x001, 0x001, 0x001, 0x005, 0x007, 0x001, 0x005, 0x007), // 12x12
+        array(0x00e, 0x00e, 0x00c, 0x00c, 0x00e, 0x00e, 0x00c, 0x00c, 0x001, 0x001, 0x001, 0x008, 0x00a, 0x001, 0x008, 0x00a), // 14x14
+        array(0x010, 0x010, 0x00e, 0x00e, 0x010, 0x010, 0x00e, 0x00e, 0x001, 0x001, 0x001, 0x00c, 0x00c, 0x001, 0x00c, 0x00c), // 16x16
+        array(0x012, 0x012, 0x010, 0x010, 0x012, 0x012, 0x010, 0x010, 0x001, 0x001, 0x001, 0x012, 0x00e, 0x001, 0x012, 0x00e), // 18x18
+        array(0x014, 0x014, 0x012, 0x012, 0x014, 0x014, 0x012, 0x012, 0x001, 0x001, 0x001, 0x016, 0x012, 0x001, 0x016, 0x012), // 20x20
+        array(0x016, 0x016, 0x014, 0x014, 0x016, 0x016, 0x014, 0x014, 0x001, 0x001, 0x001, 0x01e, 0x014, 0x001, 0x01e, 0x014), // 22x22
+        array(0x018, 0x018, 0x016, 0x016, 0x018, 0x018, 0x016, 0x016, 0x001, 0x001, 0x001, 0x024, 0x018, 0x001, 0x024, 0x018), // 24x24
+        array(0x01a, 0x01a, 0x018, 0x018, 0x01a, 0x01a, 0x018, 0x018, 0x001, 0x001, 0x001, 0x02c, 0x01c, 0x001, 0x02c, 0x01c), // 26x26
+        array(0x020, 0x020, 0x01c, 0x01c, 0x010, 0x010, 0x00e, 0x00e, 0x002, 0x002, 0x004, 0x03e, 0x024, 0x001, 0x03e, 0x024), // 32x32
+        array(0x024, 0x024, 0x020, 0x020, 0x012, 0x012, 0x010, 0x010, 0x002, 0x002, 0x004, 0x056, 0x02a, 0x001, 0x056, 0x02a), // 36x36
+        array(0x028, 0x028, 0x024, 0x024, 0x014, 0x014, 0x012, 0x012, 0x002, 0x002, 0x004, 0x072, 0x030, 0x001, 0x072, 0x030), // 40x40
+        array(0x02c, 0x02c, 0x028, 0x028, 0x016, 0x016, 0x014, 0x014, 0x002, 0x002, 0x004, 0x090, 0x038, 0x001, 0x090, 0x038), // 44x44
+        array(0x030, 0x030, 0x02c, 0x02c, 0x018, 0x018, 0x016, 0x016, 0x002, 0x002, 0x004, 0x0ae, 0x044, 0x001, 0x0ae, 0x044), // 48x48
+        array(0x034, 0x034, 0x030, 0x030, 0x01a, 0x01a, 0x018, 0x018, 0x002, 0x002, 0x004, 0x0cc, 0x054, 0x002, 0x066, 0x02a), // 52x52
+        array(0x040, 0x040, 0x038, 0x038, 0x010, 0x010, 0x00e, 0x00e, 0x004, 0x004, 0x010, 0x118, 0x070, 0x002, 0x08c, 0x038), // 64x64
+        array(0x048, 0x048, 0x040, 0x040, 0x012, 0x012, 0x010, 0x010, 0x004, 0x004, 0x010, 0x170, 0x090, 0x004, 0x05c, 0x024), // 72x72
+        array(0x050, 0x050, 0x048, 0x048, 0x014, 0x014, 0x012, 0x012, 0x004, 0x004, 0x010, 0x1c8, 0x0c0, 0x004, 0x072, 0x030), // 80x80
+        array(0x058, 0x058, 0x050, 0x050, 0x016, 0x016, 0x014, 0x014, 0x004, 0x004, 0x010, 0x240, 0x0e0, 0x004, 0x090, 0x038), // 88x88
+        array(0x060, 0x060, 0x058, 0x058, 0x018, 0x018, 0x016, 0x016, 0x004, 0x004, 0x010, 0x2b8, 0x110, 0x004, 0x0ae, 0x044), // 96x96
+        array(0x068, 0x068, 0x060, 0x060, 0x01a, 0x01a, 0x018, 0x018, 0x004, 0x004, 0x010, 0x330, 0x150, 0x006, 0x088, 0x038), // 104x104
+        array(0x078, 0x078, 0x06c, 0x06c, 0x014, 0x014, 0x012, 0x012, 0x006, 0x006, 0x024, 0x41a, 0x198, 0x006, 0x0af, 0x044), // 120x120
+        array(0x084, 0x084, 0x078, 0x078, 0x016, 0x016, 0x014, 0x014, 0x006, 0x006, 0x024, 0x518, 0x1f0, 0x008, 0x0a3, 0x03e), // 132x132
+        array(0x090, 0x090, 0x084, 0x084, 0x018, 0x018, 0x016, 0x016, 0x006, 0x006, 0x024, 0x616, 0x26c, 0x00a, 0x09c, 0x03e), // 144x144
+        // rectangular form (currently unused) ---------------------------------------------------------------------------
+        array(0x008, 0x012, 0x006, 0x010, 0x008, 0x012, 0x006, 0x010, 0x001, 0x001, 0x001, 0x005, 0x007, 0x001, 0x005, 0x007), // 8x18
+        array(0x008, 0x020, 0x006, 0x01c, 0x008, 0x010, 0x006, 0x00e, 0x001, 0x002, 0x002, 0x00a, 0x00b, 0x001, 0x00a, 0x00b), // 8x32
+        array(0x00c, 0x01a, 0x00a, 0x018, 0x00c, 0x01a, 0x00a, 0x018, 0x001, 0x001, 0x001, 0x010, 0x00e, 0x001, 0x010, 0x00e), // 12x26
+        array(0x00c, 0x024, 0x00a, 0x020, 0x00c, 0x012, 0x00a, 0x010, 0x001, 0x002, 0x002, 0x00c, 0x012, 0x001, 0x00c, 0x012), // 12x36
+        array(0x010, 0x024, 0x00e, 0x020, 0x010, 0x012, 0x00e, 0x010, 0x001, 0x002, 0x002, 0x020, 0x018, 0x001, 0x020, 0x018), // 16x36
+        array(0x010, 0x030, 0x00e, 0x02c, 0x010, 0x018, 0x00e, 0x016, 0x001, 0x002, 0x002, 0x031, 0x01c, 0x001, 0x031, 0x01c)  // 16x48
+    );
+
+    /**
+     * Map encodation modes whit character sets.
+     * @protected
+     */
+    protected $chset_id = array(ENC_C40 => 'C40', ENC_TXT => 'TXT', ENC_X12 => 'X12');
+
+    /**
+     * Basic set of charactes for each encodation mode.
+     * @protected
+     */
+    protected $chset = array(
+        'C40' => array(// Basic set for C40 ----------------------------------------------------------------------------
+            'S1' => 0x00, 'S2' => 0x01, 'S3' => 0x02, 0x20 => 0x03, 0x30 => 0x04, 0x31 => 0x05, 0x32 => 0x06, 0x33 => 0x07, 0x34 => 0x08, 0x35 => 0x09, //
+            0x36 => 0x0a, 0x37 => 0x0b, 0x38 => 0x0c, 0x39 => 0x0d, 0x41 => 0x0e, 0x42 => 0x0f, 0x43 => 0x10, 0x44 => 0x11, 0x45 => 0x12, 0x46 => 0x13, //
+            0x47 => 0x14, 0x48 => 0x15, 0x49 => 0x16, 0x4a => 0x17, 0x4b => 0x18, 0x4c => 0x19, 0x4d => 0x1a, 0x4e => 0x1b, 0x4f => 0x1c, 0x50 => 0x1d, //
+            0x51 => 0x1e, 0x52 => 0x1f, 0x53 => 0x20, 0x54 => 0x21, 0x55 => 0x22, 0x56 => 0x23, 0x57 => 0x24, 0x58 => 0x25, 0x59 => 0x26, 0x5a => 0x27), //
+        'TXT' => array(// Basic set for TEXT ---------------------------------------------------------------------------
+            'S1' => 0x00, 'S2' => 0x01, 'S3' => 0x02, 0x20 => 0x03, 0x30 => 0x04, 0x31 => 0x05, 0x32 => 0x06, 0x33 => 0x07, 0x34 => 0x08, 0x35 => 0x09, //
+            0x36 => 0x0a, 0x37 => 0x0b, 0x38 => 0x0c, 0x39 => 0x0d, 0x61 => 0x0e, 0x62 => 0x0f, 0x63 => 0x10, 0x64 => 0x11, 0x65 => 0x12, 0x66 => 0x13, //
+            0x67 => 0x14, 0x68 => 0x15, 0x69 => 0x16, 0x6a => 0x17, 0x6b => 0x18, 0x6c => 0x19, 0x6d => 0x1a, 0x6e => 0x1b, 0x6f => 0x1c, 0x70 => 0x1d, //
+            0x71 => 0x1e, 0x72 => 0x1f, 0x73 => 0x20, 0x74 => 0x21, 0x75 => 0x22, 0x76 => 0x23, 0x77 => 0x24, 0x78 => 0x25, 0x79 => 0x26, 0x7a => 0x27), //
+        'SH1' => array(// Shift 1 set ----------------------------------------------------------------------------------
+            0x00 => 0x00, 0x01 => 0x01, 0x02 => 0x02, 0x03 => 0x03, 0x04 => 0x04, 0x05 => 0x05, 0x06 => 0x06, 0x07 => 0x07, 0x08 => 0x08, 0x09 => 0x09, //
+            0x0a => 0x0a, 0x0b => 0x0b, 0x0c => 0x0c, 0x0d => 0x0d, 0x0e => 0x0e, 0x0f => 0x0f, 0x10 => 0x10, 0x11 => 0x11, 0x12 => 0x12, 0x13 => 0x13, //
+            0x14 => 0x14, 0x15 => 0x15, 0x16 => 0x16, 0x17 => 0x17, 0x18 => 0x18, 0x19 => 0x19, 0x1a => 0x1a, 0x1b => 0x1b, 0x1c => 0x1c, 0x1d => 0x1d, //
+            0x1e => 0x1e, 0x1f => 0x1f), //
+        'SH2' => array(// Shift 2 set ----------------------------------------------------------------------------------
+            0x21 => 0x00, 0x22 => 0x01, 0x23 => 0x02, 0x24 => 0x03, 0x25 => 0x04, 0x26 => 0x05, 0x27 => 0x06, 0x28 => 0x07, 0x29 => 0x08, 0x2a => 0x09, //
+            0x2b => 0x0a, 0x2c => 0x0b, 0x2d => 0x0c, 0x2e => 0x0d, 0x2f => 0x0e, 0x3a => 0x0f, 0x3b => 0x10, 0x3c => 0x11, 0x3d => 0x12, 0x3e => 0x13, //
+            0x3f => 0x14, 0x40 => 0x15, 0x5b => 0x16, 0x5c => 0x17, 0x5d => 0x18, 0x5e => 0x19, 0x5f => 0x1a, 'F1' => 0x1b, 'US' => 0x1e), //
+        'S3C' => array(// Shift 3 set for C40 --------------------------------------------------------------------------
+            0x60 => 0x00, 0x61 => 0x01, 0x62 => 0x02, 0x63 => 0x03, 0x64 => 0x04, 0x65 => 0x05, 0x66 => 0x06, 0x67 => 0x07, 0x68 => 0x08, 0x69 => 0x09, //
+            0x6a => 0x0a, 0x6b => 0x0b, 0x6c => 0x0c, 0x6d => 0x0d, 0x6e => 0x0e, 0x6f => 0x0f, 0x70 => 0x10, 0x71 => 0x11, 0x72 => 0x12, 0x73 => 0x13, //
+            0x74 => 0x14, 0x75 => 0x15, 0x76 => 0x16, 0x77 => 0x17, 0x78 => 0x18, 0x79 => 0x19, 0x7a => 0x1a, 0x7b => 0x1b, 0x7c => 0x1c, 0x7d => 0x1d, //
+            0x7e => 0x1e, 0x7f => 0x1f),
+        'S3T' => array(// Shift 3 set for TEXT -------------------------------------------------------------------------
+            0x60 => 0x00, 0x41 => 0x01, 0x42 => 0x02, 0x43 => 0x03, 0x44 => 0x04, 0x45 => 0x05, 0x46 => 0x06, 0x47 => 0x07, 0x48 => 0x08, 0x49 => 0x09, //
+            0x4a => 0x0a, 0x4b => 0x0b, 0x4c => 0x0c, 0x4d => 0x0d, 0x4e => 0x0e, 0x4f => 0x0f, 0x50 => 0x10, 0x51 => 0x11, 0x52 => 0x12, 0x53 => 0x13, //
+            0x54 => 0x14, 0x55 => 0x15, 0x56 => 0x16, 0x57 => 0x17, 0x58 => 0x18, 0x59 => 0x19, 0x5a => 0x1a, 0x7b => 0x1b, 0x7c => 0x1c, 0x7d => 0x1d, //
+            0x7e => 0x1e, 0x7f => 0x1f), //
+        'X12' => array(// Set for X12 ----------------------------------------------------------------------------------
+            0x0d => 0x00, 0x2a => 0x01, 0x3e => 0x02, 0x20 => 0x03, 0x30 => 0x04, 0x31 => 0x05, 0x32 => 0x06, 0x33 => 0x07, 0x34 => 0x08, 0x35 => 0x09, //
+            0x36 => 0x0a, 0x37 => 0x0b, 0x38 => 0x0c, 0x39 => 0x0d, 0x41 => 0x0e, 0x42 => 0x0f, 0x43 => 0x10, 0x44 => 0x11, 0x45 => 0x12, 0x46 => 0x13, //
+            0x47 => 0x14, 0x48 => 0x15, 0x49 => 0x16, 0x4a => 0x17, 0x4b => 0x18, 0x4c => 0x19, 0x4d => 0x1a, 0x4e => 0x1b, 0x4f => 0x1c, 0x50 => 0x1d, //
+            0x51 => 0x1e, 0x52 => 0x1f, 0x53 => 0x20, 0x54 => 0x21, 0x55 => 0x22, 0x56 => 0x23, 0x57 => 0x24, 0x58 => 0x25, 0x59 => 0x26, 0x5a => 0x27) //
+    );
+
+// -----------------------------------------------------------------------------
+
+    /**
+     * This is the class constructor.
+     * Creates a datamatrix object
+     * @param $code (string) Code to represent using Datamatrix.
+     * @public
+     */
+    public function __construct($code) {
+        $barcode_array = array();
+        if ((is_null($code)) OR ($code == '\0') OR ($code == '')) {
+            return false;
+        }
+        // get data codewords
+        $cw = $this->getHighLevelEncoding($code);
+        // number of data codewords
+        $nd = count($cw);
+        // check size
+        if ($nd > 1558) {
+            return false;
+        }
+        // get minimum required matrix size.
+        foreach ($this->symbattr as $params) {
+            if ($params[11] >= $nd) {
+                break;
+            }
+        }
+        if ($params[11] < $nd) {
+            // too much data
+            return false;
+        } elseif ($params[11] > $nd) {
+            // add padding
+            if ($this->last_enc == ENC_EDF) {
+                // switch to ASCII encoding
+                $cw[] = 124;
+                ++$nd;
+            } elseif (($this->last_enc != ENC_ASCII) AND ($this->last_enc != ENC_BASE256)) {
+                // switch to ASCII encoding
+                $cw[] = 254;
+                ++$nd;
+            }
+            if ($params[11] > $nd) {
+                // add first pad
+                $cw[] = 129;
+                ++$nd;
+                // add remaining pads
+                for ($i = $nd; $i <= $params[11]; ++$i) {
+                    $cw[] = $this->get253StateCodeword(129, $i);
+                }
+            }
+        }
+        // add error correction codewords
+        $cw = $this->getErrorCorrection($cw, $params[13], $params[14], $params[15]);
+        // initialize empty arrays
+        $grid = array_fill(0, ($params[2] * $params[3]), 0);
+        // get placement map
+        $places = $this->getPlacemetMap($params[2], $params[3]);
+        // fill the grid with data
+        $grid = array();
+        $i = 0;
+        // region data row max index
+        $rdri = ($params[4] - 1);
+        // region data column max index
+        $rdci = ($params[5] - 1);
+        // for each vertical region
+        for ($vr = 0; $vr < $params[9]; ++$vr) {
+            // for each row on region
+            for ($r = 0; $r < $params[4]; ++$r) {
+                // get row
+                $row = (($vr * $params[4]) + $r);
+                // for each horizontal region
+                for ($hr = 0; $hr < $params[8]; ++$hr) {
+                    // for each column on region
+                    for ($c = 0; $c < $params[5]; ++$c) {
+                        // get column
+                        $col = (($hr * $params[5]) + $c);
+                        // braw bits by case
+                        if ($r == 0) {
+                            // top finder pattern
+                            if ($c % 2) {
+                                $grid[$row][$col] = 0;
+                            } else {
+                                $grid[$row][$col] = 1;
+                            }
+                        } elseif ($r == $rdri) {
+                            // bottom finder pattern
+                            $grid[$row][$col] = 1;
+                        } elseif ($c == 0) {
+                            // left finder pattern
+                            $grid[$row][$col] = 1;
+                        } elseif ($c == $rdci) {
+                            // right finder pattern
+                            if ($r % 2) {
+                                $grid[$row][$col] = 1;
+                            } else {
+                                $grid[$row][$col] = 0;
+                            }
+                        } else { // data bit
+                            if ($places[$i] < 2) {
+                                $grid[$row][$col] = $places[$i];
+                            } else {
+                                // codeword ID
+                                $cw_id = (floor($places[$i] / 10) - 1);
+                                // codeword BIT mask
+                                $cw_bit = pow(2, (8 - ($places[$i] % 10)));
+                                $grid[$row][$col] = (($cw[$cw_id] & $cw_bit) == 0) ? 0 : 1;
+                            }
+                            ++$i;
+                        }
+                    }
+                }
+            }
+        }
+        $this->barcode_array['num_rows'] = $params[0];
+        $this->barcode_array['num_cols'] = $params[1];
+        $this->barcode_array['bcode'] = $grid;
+    }
+
+    /**
+     * Returns a barcode array which is readable by Dinesh Rabara
+     * @return array barcode array readable by Dinesh Rabara;
+     * @public
+     */
+    public function getBarcodeArray() {
+        return $this->barcode_array;
+    }
+
+    /**
+     * Product of two numbers in a Power-of-Two Galois Field
+     * @param $a (int) first number to multiply.
+     * @param $b (int) second number to multiply.
+     * @param $log (array) Log table.
+     * @param $alog (array) Anti-Log table.
+     * @param $gf (array) Number of Factors of the Reed-Solomon polynomial.
+     * @return int product
+     * @protected
+     */
+    protected function getGFProduct($a, $b, $log, $alog, $gf) {
+        if (($a == 0) OR ($b == 0)) {
+            return 0;
+        }
+        return $alog[($log[$a] + $log[$b]) % ($gf - 1)];
+    }
+
+    /**
+     * Add error correction codewords to data codewords array (ANNEX E).
+     * @param $wd (array) Array of datacodewords.
+     * @param $nb (int) Number of blocks.
+     * @param $nd (int) Number of data codewords per block.
+     * @param $nc (int) Number of correction codewords per block.
+     * @param $gf (int) numner of fields on log/antilog table (power of 2).
+     * @param $pp (int) The value of its prime modulus polynomial (301 for ECC200).
+     * @return array data codewords + error codewords
+     * @protected
+     */
+    protected function getErrorCorrection($wd, $nb, $nd, $nc, $gf = 256, $pp = 301) {
+        // generate the log ($log) and antilog ($alog) tables
+        $log[0] = 0;
+        $alog[0] = 1;
+        for ($i = 1; $i < $gf; ++$i) {
+            $alog[$i] = ($alog[($i - 1)] * 2);
+            if ($alog[$i] >= $gf) {
+                $alog[$i] ^= $pp;
+            }
+            $log[$alog[$i]] = $i;
+        }
+        ksort($log);
+        // generate the polynomial coefficients (c)
+        $c = array_fill(0, ($nc + 1), 0);
+        $c[0] = 1;
+        for ($i = 1; $i <= $nc; ++$i) {
+            $c[$i] = $c[($i - 1)];
+            for ($j = ($i - 1); $j >= 1; --$j) {
+                $c[$j] = $c[($j - 1)] ^ $this->getGFProduct($c[$j], $alog[$i], $log, $alog, $gf);
+            }
+            $c[0] = $this->getGFProduct($c[0], $alog[$i], $log, $alog, $gf);
+        }
+        ksort($c);
+        // total number of data codewords
+        $num_wd = ($nb * $nd);
+        // total number of error codewords
+        $num_we = ($nb * $nc);
+        // for each block
+        for ($b = 0; $b < $nb; ++$b) {
+            // create interleaved data block
+            $block = array();
+            for ($n = $b; $n < $num_wd; $n += $nb) {
+                $block[] = $wd[$n];
+            }
+            // initialize error codewords
+            $we = array_fill(0, ($nc + 1), 0);
+            // calculate error correction codewords for this block
+            for ($i = 0; $i < $nd; ++$i) {
+                $k = ($we[0] ^ $block[$i]);
+                for ($j = 0; $j < $nc; ++$j) {
+                    $we[$j] = ($we[($j + 1)] ^ $this->getGFProduct($k, $c[($nc - $j - 1)], $log, $alog, $gf));
+                }
+            }
+            // add error codewords at the end of data codewords
+            $j = 0;
+            for ($i = $b; $i < $num_we; $i += $nb) {
+                $wd[($num_wd + $i)] = $we[$j];
+                ++$j;
+            }
+        }
+        // reorder codewords
+        ksort($wd);
+        return $wd;
+    }
+
+    /**
+     * Return the 253-state codeword
+     * @param $cwpad (int) Pad codeword.
+     * @param $cwpos (int) Number of data codewords from the beginning of encoded data.
+     * @return pad codeword
+     * @protected
+     */
+    protected function get253StateCodeword($cwpad, $cwpos) {
+        $pad = ($cwpad + (((149 * $cwpos) % 253) + 1));
+        if ($pad > 254) {
+            $pad -= 254;
+        }
+        return $pad;
+    }
+
+    /**
+     * Return the 255-state codeword
+     * @param $cwpad (int) Pad codeword.
+     * @param $cwpos (int) Number of data codewords from the beginning of encoded data.
+     * @return pad codeword
+     * @protected
+     */
+    protected function get255StateCodeword($cwpad, $cwpos) {
+        $pad = ($cwpad + (((149 * $cwpos) % 255) + 1));
+        if ($pad > 255) {
+            $pad -= 256;
+        }
+        return $pad;
+    }
+
+    /**
+     * Returns true if the char belongs to the selected mode
+     * @param $chr (int) Character (byte) to check.
+     * @param $mode (int) Current encoding mode.
+     * @return boolean true if the char is of the selected mode.
+     * @protected
+     */
+    protected function isCharMode($chr, $mode) {
+        $status = false;
+        switch ($mode) {
+            case ENC_ASCII: { // ASCII character 0 to 127
+                    $status = (($chr >= 0) AND ($chr <= 127));
+                    break;
+                }
+            case ENC_C40: { // Upper-case alphanumeric
+                    $status = (($chr == 32) OR (($chr >= 48) AND ($chr <= 57)) OR (($chr >= 65) AND ($chr <= 90)));
+                    break;
+                }
+            case ENC_TXT: { // Lower-case alphanumeric
+                    $status = (($chr == 32) OR (($chr >= 48) AND ($chr <= 57)) OR (($chr >= 97) AND ($chr <= 122)));
+                    break;
+                }
+            case ENC_X12: { // ANSI X12
+                    $status = (($chr == 13) OR ($chr == 42) OR ($chr == 62));
+                    break;
+                }
+            case ENC_EDF: { // ASCII character 32 to 94
+                    $status = (($chr >= 32) AND ($chr <= 94));
+                    break;
+                }
+            case ENC_BASE256: { // Function character (FNC1, Structured Append, Reader Program, or Code Page)
+                    $status = (($chr == 232) OR ($chr == 233) OR ($chr == 234) OR ($chr == 241));
+                    break;
+                }
+            case ENC_ASCII_EXT: { // ASCII character 128 to 255
+                    $status = (($chr >= 128) AND ($chr <= 255));
+                    break;
+                }
+            case ENC_ASCII_NUM: { // ASCII digits
+                    $status = (($chr >= 48) AND ($chr <= 57));
+                    break;
+                }
+        }
+        return $status;
+    }
+
+    /**
+     * The look-ahead test scans the data to be encoded to find the best mode (Annex P - steps from J to S).
+     * @param $data (string) data to encode
+     * @param $pos (int) current position
+     * @param $mode (int) current encoding mode
+     * @return int encoding mode
+     * @protected
+     */
+    protected function lookAheadTest($data, $pos, $mode) {
+        $data_length = strlen($data);
+        if ($pos >= $data_length) {
+            return $mode;
+        }
+        $charscount = 0; // count processed chars
+        // STEP J
+        if ($mode == ENC_ASCII) {
+            $numch = array(0, 1, 1, 1, 1, 1.25);
+        } else {
+            $numch = array(1, 2, 2, 2, 2, 2.25);
+            $numch[$mode] = 0;
+        }
+        while (true) {
+            // STEP K
+            if (($pos + $charscount) == $data_length) {
+                if ($numch[ENC_ASCII] <= ceil(min($numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_EDF], $numch[ENC_BASE256]))) {
+                    return ENC_ASCII;
+                }
+                if ($numch[ENC_BASE256] < ceil(min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_EDF]))) {
+                    return ENC_BASE256;
+                }
+                if ($numch[ENC_EDF] < ceil(min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_BASE256]))) {
+                    return ENC_EDF;
+                }
+                if ($numch[ENC_TXT] < ceil(min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_X12], $numch[ENC_EDF], $numch[ENC_BASE256]))) {
+                    return ENC_TXT;
+                }
+                if ($numch[ENC_X12] < ceil(min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_EDF], $numch[ENC_BASE256]))) {
+                    return ENC_X12;
+                }
+                return ENC_C40;
+            }
+            // get char
+            $chr = ord($data{($pos + $charscount)});
+            $charscount++;
+            // STEP L
+            if ($this->isCharMode($chr, ENC_ASCII_NUM)) {
+                $numch[ENC_ASCII] += (1 / 2);
+            } elseif ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                $numch[ENC_ASCII] = ceil($numch[ENC_ASCII]);
+                $numch[ENC_ASCII] += 2;
+            } else {
+                $numch[ENC_ASCII] = ceil($numch[ENC_ASCII]);
+                $numch[ENC_ASCII] += 1;
+            }
+            // STEP M
+            if ($this->isCharMode($chr, ENC_C40)) {
+                $numch[ENC_C40] += (2 / 3);
+            } elseif ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                $numch[ENC_C40] += (8 / 3);
+            } else {
+                $numch[ENC_C40] += (4 / 3);
+            }
+            // STEP N
+            if ($this->isCharMode($chr, ENC_TXT)) {
+                $numch[ENC_TXT] += (2 / 3);
+            } elseif ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                $numch[ENC_TXT] += (8 / 3);
+            } else {
+                $numch[ENC_TXT] += (4 / 3);
+            }
+            // STEP O
+            if ($this->isCharMode($chr, ENC_X12) OR $this->isCharMode($chr, ENC_C40)) {
+                $numch[ENC_X12] += (2 / 3);
+            } elseif ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                $numch[ENC_X12] += (13 / 3);
+            } else {
+                $numch[ENC_X12] += (10 / 3);
+            }
+            // STEP P
+            if ($this->isCharMode($chr, ENC_EDF)) {
+                $numch[ENC_EDF] += (3 / 4);
+            } elseif ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                $numch[ENC_EDF] += (17 / 4);
+            } else {
+                $numch[ENC_EDF] += (13 / 4);
+            }
+            // STEP Q
+            if ($this->isCharMode($chr, ENC_BASE256)) {
+                $numch[ENC_BASE256] += 4;
+            } else {
+                $numch[ENC_BASE256] += 1;
+            }
+            // STEP R
+            if ($charscount >= 4) {
+                if (($numch[ENC_ASCII] + 1) <= min($numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_EDF], $numch[ENC_BASE256])) {
+                    return ENC_ASCII;
+                }
+                if ((($numch[ENC_BASE256] + 1) <= $numch[ENC_ASCII])
+                        OR (($numch[ENC_BASE256] + 1) < min($numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_EDF]))) {
+                    return ENC_BASE256;
+                }
+                if (($numch[ENC_EDF] + 1) < min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_X12], $numch[ENC_BASE256])) {
+                    return ENC_EDF;
+                }
+                if (($numch[ENC_TXT] + 1) < min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_X12], $numch[ENC_EDF], $numch[ENC_BASE256])) {
+                    return ENC_TXT;
+                }
+                if (($numch[ENC_X12] + 1) < min($numch[ENC_ASCII], $numch[ENC_C40], $numch[ENC_TXT], $numch[ENC_EDF], $numch[ENC_BASE256])) {
+                    return ENC_X12;
+                }
+                if (($numch[ENC_C40] + 1) < min($numch[ENC_ASCII], $numch[ENC_TXT], $numch[ENC_EDF], $numch[ENC_BASE256])) {
+                    if ($numch[ENC_C40] < $numch[ENC_X12]) {
+                        return ENC_C40;
+                    }
+                    if ($numch[ENC_C40] == $numch[ENC_X12]) {
+                        $k = ($pos + $charscount + 1);
+                        while ($k < $data_length) {
+                            $tmpchr = ord($data{$k});
+                            if ($this->isCharMode($tmpchr, ENC_X12)) {
+                                return ENC_X12;
+                            } elseif (!($this->isCharMode($tmpchr, ENC_X12) OR $this->isCharMode($tmpchr, ENC_C40))) {
+                                break;
+                            }
+                            ++$k;
+                        }
+                        return ENC_C40;
+                    }
+                }
+            }
+        } // end of while
+    }
+
+    /**
+     * Get the switching codeword to a new encoding mode (latch codeword)
+     * @param $mode (int) New encoding mode.
+     * @return (int) Switch codeword.
+     * @protected
+     */
+    protected function getSwitchEncodingCodeword($mode) {
+        switch ($mode) {
+            case ENC_ASCII: { // ASCII character 0 to 127
+                    $cw = 254;
+                    break;
+                }
+            case ENC_C40: { // Upper-case alphanumeric
+                    $cw = 230;
+                    break;
+                }
+            case ENC_TXT: { // Lower-case alphanumeric
+                    $cw = 239;
+                    break;
+                }
+            case ENC_X12: { // ANSI X12
+                    $cw = 238;
+                    break;
+                }
+            case ENC_EDF: { // ASCII character 32 to 94
+                    $cw = 240;
+                    break;
+                }
+            case ENC_BASE256: { // Function character (FNC1, Structured Append, Reader Program, or Code Page)
+                    $cw = 231;
+                    break;
+                }
+        }
+        return $cw;
+    }
+
+    /**
+     * Choose the minimum matrix size and return the max number of data codewords.
+     * @param $numcw (int) Number of current codewords.
+     * @return number of data codewords in matrix
+     * @protected
+     */
+    protected function getMaxDataCodewords($numcw) {
+        foreach ($this->symbattr as $key => $matrix) {
+            if ($matrix[11] >= $numcw) {
+                return $matrix[11];
+            }
+        }
+        return 0;
+    }
+
+    /**
+     * Get high level encoding using the minimum symbol data characters for ECC 200
+     * @param $data (string) data to encode
+     * @return array of codewords
+     * @protected
+     */
+    protected function getHighLevelEncoding($data) {
+        // STEP A. Start in ASCII encodation.
+        $enc = ENC_ASCII; // current encoding mode
+        $pos = 0; // current position
+        $cw = array(); // array of codewords to be returned
+        $cw_num = 0; // number of data codewords
+        $data_lenght = strlen($data); // number of chars
+        while ($pos < $data_lenght) {
+            switch ($enc) {
+                case ENC_ASCII: { // STEP B. While in ASCII encodation
+                        if (($data_lenght > 1) AND ($pos < ($data_lenght - 1)) AND ($this->isCharMode(ord($data{($pos)}), ENC_ASCII_NUM) AND $this->isCharMode(ord($data{($pos + 1)}), ENC_ASCII_NUM))) {
+                            // 1. If the next data sequence is at least 2 consecutive digits, encode the next two digits as a double digit in ASCII mode.
+                            $cw[] = (intval(substr($data, $pos, 2)) + 130);
+                            ++$cw_num;
+                            $pos += 2;
+                        } else {
+                            // 2. If the look-ahead test (starting at step J) indicates another mode, switch to that mode.
+                            $newenc = $this->lookAheadTest($data, $pos, $enc);
+                            if ($newenc != $enc) {
+                                // switch to new encoding
+                                $enc = $newenc;
+                                $cw[] = $this->getSwitchEncodingCodeword($enc);
+                                ++$cw_num;
+                            } else {
+                                // get new byte
+                                $chr = ord($data{($pos)});
+                                ++$pos;
+                                if ($this->isCharMode($chr, ENC_ASCII_EXT)) {
+                                    // 3. If the next data character is extended ASCII (greater than 127) encode it in ASCII mode first using the Upper Shift (value 235) character.
+                                    $cw[] = 235;
+                                    $cw[] = ($chr - 127);
+                                    $cw_num += 2;
+                                } else {
+                                    // 4. Otherwise process the next data character in ASCII encodation.
+                                    $cw[] = ($chr + 1);
+                                    ++$cw_num;
+                                }
+                            }
+                        }
+                        break;
+                    }
+                case ENC_C40 :   // Upper-case alphanumeric
+                case ENC_TXT :   // Lower-case alphanumeric
+                case ENC_X12 : { // ANSI X12
+                        $temp_cw = array();
+                        $p = 0;
+                        $epos = $pos;
+                        // get charset ID
+                        $set_id = $this->chset_id[$enc];
+                        // get basic charset for current encoding
+                        $charset = $this->chset[$set_id];
+                        do {
+                            // 2. process the next character in C40 encodation.
+                            $chr = ord($data{($epos)});
+                            ++$epos;
+                            // check for extended character
+                            if ($chr & 0x80) {
+                                if ($enc == ENC_X12) {
+                                    return false;
+                                }
+                                $chr = ($chr & 0x7f);
+                                $temp_cw[] = 1; // shift 2
+                                $temp_cw[] = 30; // upper shift
+                                $p += 2;
+                            }
+                            if (isset($charset[$chr])) {
+                                $temp_cw[] = $charset[$chr];
+                                ++$p;
+                            } else {
+                                if (isset($this->chset['SH1'][$chr])) {
+                                    $temp_cw[] = 0; // shift 1
+                                    $shiftset = $this->chset['SH1'];
+                                } elseif (isset($chr, $this->chset['SH2'][$chr])) {
+                                    $temp_cw[] = 1; // shift 2
+                                    $shiftset = $this->chset['SH2'];
+                                } elseif (($enc == ENC_C40) AND isset($this->chset['S3C'][$chr])) {
+                                    $temp_cw[] = 2; // shift 3
+                                    $shiftset = $this->chset['S3C'];
+                                } elseif (($enc == ENC_TXT) AND isset($this->chset['S3T'][$chr])) {
+                                    $temp_cw[] = 2; // shift 3
+                                    $shiftset = $this->chset['S3T'];
+                                } else {
+                                    return false;
+                                }
+                                $temp_cw[] = $shiftset[$chr];
+                                $p += 2;
+                            }
+                            if ($p >= 3) {
+                                $c1 = array_shift($temp_cw);
+                                $c2 = array_shift($temp_cw);
+                                $c3 = array_shift($temp_cw);
+                                $p -= 3;
+                                $tmp = ((1600 * $c1) + (40 * $c2) + $c3 + 1);
+                                $cw[] = ($tmp >> 8);
+                                $cw[] = ($tmp % 256);
+                                $cw_num += 2;
+                                $pos = $epos;
+                                // 1. If the C40 encoding is at the point of starting a new double symbol character and if the look-ahead test (starting at step J) indicates another mode, switch to that mode.
+                                $newenc = $this->lookAheadTest($data, $pos, $enc);
+                                if ($newenc != $enc) {
+                                    $enc = $newenc;
+                                    $cw[] = $this->getSwitchEncodingCodeword($enc);
+                                    ++$cw_num;
+                                    break;
+                                }
+                            }
+                        } while (($p > 0) AND ($epos < $data_lenght));
+                        // process last data (if any)
+                        if ($p > 0) {
+                            // get remaining number of data symbols
+                            $cwr = ($this->getMaxDataCodewords($cw_num + 2) - $cw_num);
+                            if (($cwr == 1) AND ($p == 1)) {
+                                // d. If one symbol character remains and one C40 value (data character) remains to be encoded
+                                $c1 = array_shift($temp_cw);
+                                --$p;
+                                $cw[] = ($c1 + 1);
+                                ++$cw_num;
+                            } elseif (($cwr == 2) AND ($p == 1)) {
+                                // c. If two symbol characters remain and only one C40 value (data character) remains to be encoded
+                                $c1 = array_shift($temp_cw);
+                                --$p;
+                                $cw[] = 254;
+                                $cw[] = ($c1 + 1);
+                                $cw_num += 2;
+                            } elseif (($cwr == 2) AND ($p == 2)) {
+                                // b. If two symbol characters remain and two C40 values remain to be encoded
+                                $c1 = array_shift($temp_cw);
+                                $c2 = array_shift($temp_cw);
+                                $p -= 2;
+                                $tmp = ((1600 * $c1) + (40 * $c2) + 1);
+                                $cw[] = ($tmp >> 8);
+                                $cw[] = ($tmp % 256);
+                                $cw_num += 2;
+                            } else {
+                                // switch to ASCII encoding
+                                $enc = ENC_ASCII;
+                                $cw[] = $this->getSwitchEncodingCodeword($enc);
+                                ++$cw_num;
+                            }
+                        }
+                        break;
+                    }
+                case ENC_EDF: { // F. While in EDIFACT (EDF) encodation
+                        // initialize temporary array with 0 lenght
+                        $temp_cw = array();
+                        $epos = $pos;
+                        $field_lenght = 0;
+                        while ($epos < $data_lenght) {
+                            // 2. process the next character in EDIFACT encodation.
+                            $chr = ord($data{($epos)});
+                            ++$epos;
+                            $temp_cw[] = $chr;
+                            ++$field_lenght;
+                            if (($field_lenght == 4) OR ($epos == $data_lenght)) {
+                                if ($field_lenght < 4) {
+                                    // set unlatch character
+                                    $temp_cw[] = 0x1f;
+                                    ++$field_lenght;
+                                    $enc = ENC_ASCII;
+                                    // fill empty characters
+                                    for ($i = $field_lenght; $i < 4; ++$i) {
+                                        $temp_cw[] = 0;
+                                    }
+                                }
+                                // encodes four data characters in three codewords
+                                $cw[] = (($temp_cw[0] & 0x3F) << 2) + (($temp_cw[1] & 0x30) >> 4);
+                                $cw[] = (($temp_cw[1] & 0x0F) << 4) + (($temp_cw[2] & 0x3C) >> 2);
+                                $cw[] = (($temp_cw[2] & 0x03) << 6) + ($temp_cw[3] & 0x3F);
+                                $cw_num += 3;
+                                $temp_cw = array();
+                                $pos = $epos;
+                                $field_lenght = 0;
+                            }
+                            // 1. If the EDIFACT encoding is at the point of starting a new triple symbol character and if the look-ahead test (starting at step J) indicates another mode, switch to that mode.
+                            if ($field_lenght == 0) {
+                                // get remaining number of data symbols
+                                $cwr = ($this->getMaxDataCodewords($cw_num + 2) - $cw_num);
+                                if ($cwr < 3) {
+                                    // return to ascii without unlatch
+                                    $enc = ENC_ASCII;
+                                    break; // exit from EDIFACT mode
+                                } else {
+                                    $newenc = $this->lookAheadTest($data, $pos, $enc);
+                                    if ($newenc != $enc) {
+                                        // 1. If the look-ahead test (starting at step J) indicates another mode, switch to that mode.
+                                        $enc = $newenc;
+                                        $cw[] = $this->getSwitchEncodingCodeword($enc);
+                                        ++$cw_num;
+                                        break; // exit from EDIFACT mode
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    }
+                case ENC_BASE256: { // G. While in Base 256 (B256) encodation
+                        // initialize temporary array with 0 lenght
+                        $temp_cw = array();
+                        $field_lenght = 0;
+                        while (($pos < $data_lenght) AND ($field_lenght <= 1555)) {
+                            $newenc = $this->lookAheadTest($data, $pos, $enc);
+                            if ($newenc != $enc) {
+                                // 1. If the look-ahead test (starting at step J) indicates another mode, switch to that mode.
+                                $enc = $newenc;
+                                $cw[] = $this->getSwitchEncodingCodeword($enc);
+                                ++$cw_num;
+                                break; // exit from B256 mode
+                            } else {
+                                // 2. Otherwise, process the next character in Base 256 encodation.
+                                $chr = ord($data{($pos)});
+                                ++$pos;
+                                $temp_cw[] = $chr;
+                                ++$field_lenght;
+                            }
+                        }
+                        // set field lenght
+                        if ($field_lenght <= 249) {
+                            $cw[] = $field_lenght;
+                            ++$cw_num;
+                        } else {
+                            $cw[] = (floor($field_lenght / 250) + 249);
+                            $cw[] = ($field_lenght % 250);
+                            $cw_num += 2;
+                        }
+                        if (!empty($temp_cw)) {
+                            // add B256 field
+                            foreach ($temp_cw as $p => $cht) {
+                                $cw[] = $this->get255StateCodeword($chr, ($cw_num + $p));
+                            }
+                        }
+                        break;
+                    }
+            } // end of switch enc
+        } // end of while
+        // set last used encoding
+        $this->last_enc = $enc;
+        return $cw;
+    }
+
+    /**
+     * Places "chr+bit" with appropriate wrapping within array[].
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $row (int) Row number.
+     * @param $col (int) Column number.
+     * @param $chr (int) Char byte.
+     * @param $bit (int) Bit.
+     * @return array
+     * @protected
+     */
+    protected function placeModule($marr, $nrow, $ncol, $row, $col, $chr, $bit) {
+        if ($row < 0) {
+            $row += $nrow;
+            $col += (4 - (($nrow + 4) % 8));
+        }
+        if ($col < 0) {
+            $col += $ncol;
+            $row += (4 - (($ncol + 4) % 8));
+        }
+        $marr[(($row * $ncol) + $col)] = ((10 * $chr) + $bit);
+        return $marr;
+    }
+
+    /**
+     * Places the 8 bits of a utah-shaped symbol character.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $row (int) Row number.
+     * @param $col (int) Column number.
+     * @param $chr (int) Char byte.
+     * @return array
+     * @protected
+     */
+    protected function placeUtah($marr, $nrow, $ncol, $row, $col, $chr) {
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row - 2, $col - 2, $chr, 1);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row - 2, $col - 1, $chr, 2);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row - 1, $col - 2, $chr, 3);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row - 1, $col - 1, $chr, 4);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row - 1, $col, $chr, 5);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row, $col - 2, $chr, 6);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row, $col - 1, $chr, 7);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $row, $col, $chr, 8);
+        return $marr;
+    }
+
+    /**
+     * Places the 8 bits of the first special corner case.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $chr (int) Char byte.
+     * @return array
+     * @protected
+     */
+    protected function placeCornerA($marr, $nrow, $ncol, $chr) {
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 0, $chr, 1);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 1, $chr, 2);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 2, $chr, 3);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 2, $chr, 4);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 1, $chr, 5);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 1, $chr, 6);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 2, $ncol - 1, $chr, 7);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 3, $ncol - 1, $chr, 8);
+        return $marr;
+    }
+
+    /**
+     * Places the 8 bits of the second special corner case.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $chr (int) Char byte.
+     * @return array
+     * @protected
+     */
+    protected function placeCornerB($marr, $nrow, $ncol, $chr) {
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 3, 0, $chr, 1);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 2, 0, $chr, 2);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 0, $chr, 3);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 4, $chr, 4);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 3, $chr, 5);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 2, $chr, 6);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 1, $chr, 7);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 1, $chr, 8);
+        return $marr;
+    }
+
+    /**
+     * Places the 8 bits of the third special corner case.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $chr (int) Char byte.
+     * @return array
+     * @protected
+     */
+    protected function placeCornerC($marr, $nrow, $ncol, $chr) {
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 3, 0, $chr, 1);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 2, 0, $chr, 2);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 0, $chr, 3);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 2, $chr, 4);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 1, $chr, 5);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 1, $chr, 6);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 2, $ncol - 1, $chr, 7);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 3, $ncol - 1, $chr, 8);
+        return $marr;
+    }
+
+    /**
+     * Places the 8 bits of the fourth special corner case.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $marr (array) Array of symbols.
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @param $chr (int) Char byte.
+     * @return array
+     * @protected
+     */
+    protected function placeCornerD($marr, $nrow, $ncol, $chr) {
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, 0, $chr, 1);
+        $marr = $this->placeModule($marr, $nrow, $ncol, $nrow - 1, $ncol - 1, $chr, 2);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 3, $chr, 3);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 2, $chr, 4);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 0, $ncol - 1, $chr, 5);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 3, $chr, 6);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 2, $chr, 7);
+        $marr = $this->placeModule($marr, $nrow, $ncol, 1, $ncol - 1, $chr, 8);
+        return $marr;
+    }
+
+    /**
+     * Build a placement map.
+     * (Annex F - ECC 200 symbol character placement)
+     * @param $nrow (int) Number of rows.
+     * @param $ncol (int) Number of columns.
+     * @return array
+     * @protected
+     */
+    protected function getPlacemetMap($nrow, $ncol) {
+        // initialize array with zeros
+        $marr = array_fill(0, ($nrow * $ncol), 0);
+        // set starting values
+        $chr = 1;
+        $row = 4;
+        $col = 0;
+        do {
+            // repeatedly first check for one of the special corner cases, then
+            if (($row == $nrow) AND ($col == 0)) {
+                $marr = $this->placeCornerA($marr, $nrow, $ncol, $chr);
+                ++$chr;
+            }
+            if (($row == ($nrow - 2)) AND ($col == 0) AND ($ncol % 4)) {
+                $marr = $this->placeCornerB($marr, $nrow, $ncol, $chr);
+                ++$chr;
+            }
+            if (($row == ($nrow - 2)) AND ($col == 0) AND (($ncol % 8) == 4)) {
+                $marr = $this->placeCornerC($marr, $nrow, $ncol, $chr);
+                ++$chr;
+            }
+            if (($row == ($nrow + 4)) AND ($col == 2) AND (!($ncol % 8))) {
+                $marr = $this->placeCornerD($marr, $nrow, $ncol, $chr);
+                ++$chr;
+            }
+            // sweep upward diagonally, inserting successive characters,
+            do {
+                if (($row < $nrow) AND ($col >= 0) AND (!$marr[(($row * $ncol) + $col)])) {
+                    $marr = $this->placeUtah($marr, $nrow, $ncol, $row, $col, $chr);
+                    ++$chr;
+                }
+                $row -= 2;
+                $col += 2;
+            } while (($row >= 0) AND ($col < $ncol));
+            ++$row;
+            $col += 3;
+            // & then sweep downward diagonally, inserting successive characters,...
+            do {
+                if (($row >= 0) AND ($col < $ncol) AND (!$marr[(($row * $ncol) + $col)])) {
+                    $marr = $this->placeUtah($marr, $nrow, $ncol, $row, $col, $chr);
+                    ++$chr;
+                }
+                $row += 2;
+                $col -= 2;
+            } while (($row < $nrow) AND ($col >= 0));
+            $row += 3;
+            ++$col;
+            // ... until the entire array is scanned
+        } while (($row < $nrow) OR ($col < $ncol));
+        // lastly, if the lower righthand corner is untouched, fill in fixed pattern
+        if (!$marr[(($nrow * $ncol) - 1)]) {
+            $marr[(($nrow * $ncol) - 1)] = 1;
+            $marr[(($nrow * $ncol) - $ncol - 2)] = 1;
+        }
+        return $marr;
+    }
+
+}
+
+// end DataMatrix class
+//============================================================+
+// END OF FILE
+//============================================================+

vendor/milon/barcode/src/Milon/Barcode/Facades/DNS1DFacade.php

+<?php namespace Milon\Barcode\Facades;
+
+use Illuminate\Support\Facades\Facade;
+
+class DNS1DFacade extends Facade {
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor() {
+        return 'DNS1D';
+    }
+
+}

vendor/milon/barcode/src/Milon/Barcode/Facades/DNS2DFacade.php

+<?php namespace Milon\Barcode\Facades;
+
+use Illuminate\Support\Facades\Facade;
+
+class DNS2DFacade extends Facade {
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor() {
+        return 'DNS2D';
+    }
+
+}

vendor/milon/barcode/src/Milon/Barcode/PDF417.php

+<?php 
+
+namespace Milon\Barcode;
+
+//============================================================+
+// File name   : pdf417.php
+// Version     : 1.0.005
+// Begin       : 2010-06-03
+// Last Update : 2014-04-25
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2010-2013  Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <http://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// DESCRIPTION :
+//
+// Class to create PDF417 barcode arrays for TCPDF class.
+// PDF417 (ISO/IEC 15438:2006) is a 2-dimensional stacked bar code created by Symbol Technologies in 1991.
+// It is one of the most popular 2D codes because of its ability to be read with slightly modified handheld laser or linear CCD scanners.
+// TECHNICAL DATA / FEATURES OF PDF417:
+//      Encodable Character Set:     All 128 ASCII Characters (including extended)
+//      Code Type:                   Continuous, Multi-Row
+//      Symbol Height:               3 - 90 Rows
+//      Symbol Width:                90X - 583X
+//      Bidirectional Decoding:      Yes
+//      Error Correction Characters: 2 - 512
+//      Maximum Data Characters:     1850 text, 2710 digits, 1108 bytes
+//
+//============================================================+
+/**
+ * @file
+ * Class to create PDF417 barcode arrays for TCPDF class.
+ * PDF417 (ISO/IEC 15438:2006) is a 2-dimensional stacked bar code created by Symbol Technologies in 1991.
+ * (requires PHP bcmath extension)
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.005
+ */
+
+// definitions
+if (!defined('PDF417DEFS')) {
+
+    /**
+     * Indicate that definitions for this class are set
+     */
+    define('PDF417DEFS', true);
+
+    // -----------------------------------------------------
+
+    /**
+     * Row height respect X dimension of single module
+     */
+    define('ROWHEIGHT', 4);
+
+    /**
+     * Horizontal quiet zone in modules
+     */
+    define('QUIETH', 2);
+
+    /**
+     * Vertical quiet zone in modules
+     */
+    define('QUIETV', 2);
+} // end of definitions
+// #*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#
+
+/**
+ * @class PDF417
+ * @author Dinesh Rabara
+ */
+class PDF417 {
+
+    /**
+     * Barcode array to be returned which is readable by Dinesh Rabara.
+     * @protected
+     */
+    protected $barcode_array = array();
+
+    /**
+     * Start pattern.
+     * @protected
+     */
+    protected $start_pattern = '11111111010101000';
+
+    /**
+     * Stop pattern.
+     * @protected
+     */
+    protected $stop_pattern = '111111101000101001';
+
+    /**
+     * Array of text Compaction Sub-Modes (values 0xFB - 0xFF are used for submode changers).
+     * @protected
+     */
+    protected $textsubmodes = array(
+        array(0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x20, 0xFD, 0xFE, 0xFF), // Alpha
+        array(0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x20, 0xFD, 0xFE, 0xFF), // Lower
+        array(0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x26, 0x0d, 0x09, 0x2c, 0x3a, 0x23, 0x2d, 0x2e, 0x24, 0x2f, 0x2b, 0x25, 0x2a, 0x3d, 0x5e, 0xFB, 0x20, 0xFD, 0xFE, 0xFF), // Mixed
+        array(0x3b, 0x3c, 0x3e, 0x40, 0x5b, 0x5c, 0x5d, 0x5f, 0x60, 0x7e, 0x21, 0x0d, 0x09, 0x2c, 0x3a, 0x0a, 0x2d, 0x2e, 0x24, 0x2f, 0x22, 0x7c, 0x2a, 0x28, 0x29, 0x3f, 0x7b, 0x7d, 0x27, 0xFF) // Puntuaction
+    );
+
+    /**
+     * Array of switching codes for Text Compaction Sub-Modes.
+     * @protected
+     */
+    protected $textlatch = array(
+        '01' => array(27), '02' => array(28), '03' => array(28, 25), //
+        '10' => array(28, 28), '12' => array(28), '13' => array(28, 25), //
+        '20' => array(28), '21' => array(27), '23' => array(25), //
+        '30' => array(29), '31' => array(29, 27), '32' => array(29, 28) //
+    );
+
+    /**
+     * Clusters of codewords (0, 3, 6)<br/>
+     * Values are hex equivalents of binary representation of bars (1 = bar, 0 = space).<br/>
+     * The codewords numbered from 900 to 928 have special meaning, some enable to switch between modes in order to optimise the code:<ul>
+     * <li>900 : Switch to "Text" mode</li>
+     * <li>901 : Switch to "Byte" mode</li>
+     * <li>902 : Switch to "Numeric" mode</li>
+     * <li>903 - 912 : Reserved</li>
+     * <li>913 : Switch to "Octet" only for the next codeword</li>
+     * <li>914 - 920 : Reserved</li>
+     * <li>921 : Initialization</li>
+     * <li>922 : Terminator codeword for Macro PDF control block</li>
+     * <li>923 : Sequence tag to identify the beginning of optional fields in the Macro PDF control block</li>
+     * <li>924 : Switch to "Byte" mode (If the total number of byte is multiple of 6)</li>
+     * <li>925 : Identifier for a user defined Extended Channel Interpretation (ECI)</li>
+     * <li>926 : Identifier for a general purpose ECI format</li>
+     * <li>927 : Identifier for an ECI of a character set or code page</li>
+     * <li>928 : Macro marker codeword to indicate the beginning of a Macro PDF Control Block</li>
+     * </ul>
+     * @protected
+     */
+    protected $clusters = array(
+        array(// cluster 0 -----------------------------------------------------------------------
+            0x1d5c0, 0x1eaf0, 0x1f57c, 0x1d4e0, 0x1ea78, 0x1f53e, 0x1a8c0, 0x1d470, 0x1a860, 0x15040, //  10
+            0x1a830, 0x15020, 0x1adc0, 0x1d6f0, 0x1eb7c, 0x1ace0, 0x1d678, 0x1eb3e, 0x158c0, 0x1ac70, //  20
+            0x15860, 0x15dc0, 0x1aef0, 0x1d77c, 0x15ce0, 0x1ae78, 0x1d73e, 0x15c70, 0x1ae3c, 0x15ef0, //  30
+            0x1af7c, 0x15e78, 0x1af3e, 0x15f7c, 0x1f5fa, 0x1d2e0, 0x1e978, 0x1f4be, 0x1a4c0, 0x1d270, //  40
+            0x1e93c, 0x1a460, 0x1d238, 0x14840, 0x1a430, 0x1d21c, 0x14820, 0x1a418, 0x14810, 0x1a6e0, //  50
+            0x1d378, 0x1e9be, 0x14cc0, 0x1a670, 0x1d33c, 0x14c60, 0x1a638, 0x1d31e, 0x14c30, 0x1a61c, //  60
+            0x14ee0, 0x1a778, 0x1d3be, 0x14e70, 0x1a73c, 0x14e38, 0x1a71e, 0x14f78, 0x1a7be, 0x14f3c, //  70
+            0x14f1e, 0x1a2c0, 0x1d170, 0x1e8bc, 0x1a260, 0x1d138, 0x1e89e, 0x14440, 0x1a230, 0x1d11c, //  80
+            0x14420, 0x1a218, 0x14410, 0x14408, 0x146c0, 0x1a370, 0x1d1bc, 0x14660, 0x1a338, 0x1d19e, //  90
+            0x14630, 0x1a31c, 0x14618, 0x1460c, 0x14770, 0x1a3bc, 0x14738, 0x1a39e, 0x1471c, 0x147bc, // 100
+            0x1a160, 0x1d0b8, 0x1e85e, 0x14240, 0x1a130, 0x1d09c, 0x14220, 0x1a118, 0x1d08e, 0x14210, // 110
+            0x1a10c, 0x14208, 0x1a106, 0x14360, 0x1a1b8, 0x1d0de, 0x14330, 0x1a19c, 0x14318, 0x1a18e, // 120
+            0x1430c, 0x14306, 0x1a1de, 0x1438e, 0x14140, 0x1a0b0, 0x1d05c, 0x14120, 0x1a098, 0x1d04e, // 130
+            0x14110, 0x1a08c, 0x14108, 0x1a086, 0x14104, 0x141b0, 0x14198, 0x1418c, 0x140a0, 0x1d02e, // 140
+            0x1a04c, 0x1a046, 0x14082, 0x1cae0, 0x1e578, 0x1f2be, 0x194c0, 0x1ca70, 0x1e53c, 0x19460, // 150
+            0x1ca38, 0x1e51e, 0x12840, 0x19430, 0x12820, 0x196e0, 0x1cb78, 0x1e5be, 0x12cc0, 0x19670, // 160
+            0x1cb3c, 0x12c60, 0x19638, 0x12c30, 0x12c18, 0x12ee0, 0x19778, 0x1cbbe, 0x12e70, 0x1973c, // 170
+            0x12e38, 0x12e1c, 0x12f78, 0x197be, 0x12f3c, 0x12fbe, 0x1dac0, 0x1ed70, 0x1f6bc, 0x1da60, // 180
+            0x1ed38, 0x1f69e, 0x1b440, 0x1da30, 0x1ed1c, 0x1b420, 0x1da18, 0x1ed0e, 0x1b410, 0x1da0c, // 190
+            0x192c0, 0x1c970, 0x1e4bc, 0x1b6c0, 0x19260, 0x1c938, 0x1e49e, 0x1b660, 0x1db38, 0x1ed9e, // 200
+            0x16c40, 0x12420, 0x19218, 0x1c90e, 0x16c20, 0x1b618, 0x16c10, 0x126c0, 0x19370, 0x1c9bc, // 210
+            0x16ec0, 0x12660, 0x19338, 0x1c99e, 0x16e60, 0x1b738, 0x1db9e, 0x16e30, 0x12618, 0x16e18, // 220
+            0x12770, 0x193bc, 0x16f70, 0x12738, 0x1939e, 0x16f38, 0x1b79e, 0x16f1c, 0x127bc, 0x16fbc, // 230
+            0x1279e, 0x16f9e, 0x1d960, 0x1ecb8, 0x1f65e, 0x1b240, 0x1d930, 0x1ec9c, 0x1b220, 0x1d918, // 240
+            0x1ec8e, 0x1b210, 0x1d90c, 0x1b208, 0x1b204, 0x19160, 0x1c8b8, 0x1e45e, 0x1b360, 0x19130, // 250
+            0x1c89c, 0x16640, 0x12220, 0x1d99c, 0x1c88e, 0x16620, 0x12210, 0x1910c, 0x16610, 0x1b30c, // 260
+            0x19106, 0x12204, 0x12360, 0x191b8, 0x1c8de, 0x16760, 0x12330, 0x1919c, 0x16730, 0x1b39c, // 270
+            0x1918e, 0x16718, 0x1230c, 0x12306, 0x123b8, 0x191de, 0x167b8, 0x1239c, 0x1679c, 0x1238e, // 280
+            0x1678e, 0x167de, 0x1b140, 0x1d8b0, 0x1ec5c, 0x1b120, 0x1d898, 0x1ec4e, 0x1b110, 0x1d88c, // 290
+            0x1b108, 0x1d886, 0x1b104, 0x1b102, 0x12140, 0x190b0, 0x1c85c, 0x16340, 0x12120, 0x19098, // 300
+            0x1c84e, 0x16320, 0x1b198, 0x1d8ce, 0x16310, 0x12108, 0x19086, 0x16308, 0x1b186, 0x16304, // 310
+            0x121b0, 0x190dc, 0x163b0, 0x12198, 0x190ce, 0x16398, 0x1b1ce, 0x1638c, 0x12186, 0x16386, // 320
+            0x163dc, 0x163ce, 0x1b0a0, 0x1d858, 0x1ec2e, 0x1b090, 0x1d84c, 0x1b088, 0x1d846, 0x1b084, // 330
+            0x1b082, 0x120a0, 0x19058, 0x1c82e, 0x161a0, 0x12090, 0x1904c, 0x16190, 0x1b0cc, 0x19046, // 340
+            0x16188, 0x12084, 0x16184, 0x12082, 0x120d8, 0x161d8, 0x161cc, 0x161c6, 0x1d82c, 0x1d826, // 350
+            0x1b042, 0x1902c, 0x12048, 0x160c8, 0x160c4, 0x160c2, 0x18ac0, 0x1c570, 0x1e2bc, 0x18a60, // 360
+            0x1c538, 0x11440, 0x18a30, 0x1c51c, 0x11420, 0x18a18, 0x11410, 0x11408, 0x116c0, 0x18b70, // 370
+            0x1c5bc, 0x11660, 0x18b38, 0x1c59e, 0x11630, 0x18b1c, 0x11618, 0x1160c, 0x11770, 0x18bbc, // 380
+            0x11738, 0x18b9e, 0x1171c, 0x117bc, 0x1179e, 0x1cd60, 0x1e6b8, 0x1f35e, 0x19a40, 0x1cd30, // 390
+            0x1e69c, 0x19a20, 0x1cd18, 0x1e68e, 0x19a10, 0x1cd0c, 0x19a08, 0x1cd06, 0x18960, 0x1c4b8, // 400
+            0x1e25e, 0x19b60, 0x18930, 0x1c49c, 0x13640, 0x11220, 0x1cd9c, 0x1c48e, 0x13620, 0x19b18, // 410
+            0x1890c, 0x13610, 0x11208, 0x13608, 0x11360, 0x189b8, 0x1c4de, 0x13760, 0x11330, 0x1cdde, // 420
+            0x13730, 0x19b9c, 0x1898e, 0x13718, 0x1130c, 0x1370c, 0x113b8, 0x189de, 0x137b8, 0x1139c, // 430
+            0x1379c, 0x1138e, 0x113de, 0x137de, 0x1dd40, 0x1eeb0, 0x1f75c, 0x1dd20, 0x1ee98, 0x1f74e, // 440
+            0x1dd10, 0x1ee8c, 0x1dd08, 0x1ee86, 0x1dd04, 0x19940, 0x1ccb0, 0x1e65c, 0x1bb40, 0x19920, // 450
+            0x1eedc, 0x1e64e, 0x1bb20, 0x1dd98, 0x1eece, 0x1bb10, 0x19908, 0x1cc86, 0x1bb08, 0x1dd86, // 460
+            0x19902, 0x11140, 0x188b0, 0x1c45c, 0x13340, 0x11120, 0x18898, 0x1c44e, 0x17740, 0x13320, // 470
+            0x19998, 0x1ccce, 0x17720, 0x1bb98, 0x1ddce, 0x18886, 0x17710, 0x13308, 0x19986, 0x17708, // 480
+            0x11102, 0x111b0, 0x188dc, 0x133b0, 0x11198, 0x188ce, 0x177b0, 0x13398, 0x199ce, 0x17798, // 490
+            0x1bbce, 0x11186, 0x13386, 0x111dc, 0x133dc, 0x111ce, 0x177dc, 0x133ce, 0x1dca0, 0x1ee58, // 500
+            0x1f72e, 0x1dc90, 0x1ee4c, 0x1dc88, 0x1ee46, 0x1dc84, 0x1dc82, 0x198a0, 0x1cc58, 0x1e62e, // 510
+            0x1b9a0, 0x19890, 0x1ee6e, 0x1b990, 0x1dccc, 0x1cc46, 0x1b988, 0x19884, 0x1b984, 0x19882, // 520
+            0x1b982, 0x110a0, 0x18858, 0x1c42e, 0x131a0, 0x11090, 0x1884c, 0x173a0, 0x13190, 0x198cc, // 530
+            0x18846, 0x17390, 0x1b9cc, 0x11084, 0x17388, 0x13184, 0x11082, 0x13182, 0x110d8, 0x1886e, // 540
+            0x131d8, 0x110cc, 0x173d8, 0x131cc, 0x110c6, 0x173cc, 0x131c6, 0x110ee, 0x173ee, 0x1dc50, // 550
+            0x1ee2c, 0x1dc48, 0x1ee26, 0x1dc44, 0x1dc42, 0x19850, 0x1cc2c, 0x1b8d0, 0x19848, 0x1cc26, // 560
+            0x1b8c8, 0x1dc66, 0x1b8c4, 0x19842, 0x1b8c2, 0x11050, 0x1882c, 0x130d0, 0x11048, 0x18826, // 570
+            0x171d0, 0x130c8, 0x19866, 0x171c8, 0x1b8e6, 0x11042, 0x171c4, 0x130c2, 0x171c2, 0x130ec, // 580
+            0x171ec, 0x171e6, 0x1ee16, 0x1dc22, 0x1cc16, 0x19824, 0x19822, 0x11028, 0x13068, 0x170e8, // 590
+            0x11022, 0x13062, 0x18560, 0x10a40, 0x18530, 0x10a20, 0x18518, 0x1c28e, 0x10a10, 0x1850c, // 600
+            0x10a08, 0x18506, 0x10b60, 0x185b8, 0x1c2de, 0x10b30, 0x1859c, 0x10b18, 0x1858e, 0x10b0c, // 610
+            0x10b06, 0x10bb8, 0x185de, 0x10b9c, 0x10b8e, 0x10bde, 0x18d40, 0x1c6b0, 0x1e35c, 0x18d20, // 620
+            0x1c698, 0x18d10, 0x1c68c, 0x18d08, 0x1c686, 0x18d04, 0x10940, 0x184b0, 0x1c25c, 0x11b40, // 630
+            0x10920, 0x1c6dc, 0x1c24e, 0x11b20, 0x18d98, 0x1c6ce, 0x11b10, 0x10908, 0x18486, 0x11b08, // 640
+            0x18d86, 0x10902, 0x109b0, 0x184dc, 0x11bb0, 0x10998, 0x184ce, 0x11b98, 0x18dce, 0x11b8c, // 650
+            0x10986, 0x109dc, 0x11bdc, 0x109ce, 0x11bce, 0x1cea0, 0x1e758, 0x1f3ae, 0x1ce90, 0x1e74c, // 660
+            0x1ce88, 0x1e746, 0x1ce84, 0x1ce82, 0x18ca0, 0x1c658, 0x19da0, 0x18c90, 0x1c64c, 0x19d90, // 670
+            0x1cecc, 0x1c646, 0x19d88, 0x18c84, 0x19d84, 0x18c82, 0x19d82, 0x108a0, 0x18458, 0x119a0, // 680
+            0x10890, 0x1c66e, 0x13ba0, 0x11990, 0x18ccc, 0x18446, 0x13b90, 0x19dcc, 0x10884, 0x13b88, // 690
+            0x11984, 0x10882, 0x11982, 0x108d8, 0x1846e, 0x119d8, 0x108cc, 0x13bd8, 0x119cc, 0x108c6, // 700
+            0x13bcc, 0x119c6, 0x108ee, 0x119ee, 0x13bee, 0x1ef50, 0x1f7ac, 0x1ef48, 0x1f7a6, 0x1ef44, // 710
+            0x1ef42, 0x1ce50, 0x1e72c, 0x1ded0, 0x1ef6c, 0x1e726, 0x1dec8, 0x1ef66, 0x1dec4, 0x1ce42, // 720
+            0x1dec2, 0x18c50, 0x1c62c, 0x19cd0, 0x18c48, 0x1c626, 0x1bdd0, 0x19cc8, 0x1ce66, 0x1bdc8, // 730
+            0x1dee6, 0x18c42, 0x1bdc4, 0x19cc2, 0x1bdc2, 0x10850, 0x1842c, 0x118d0, 0x10848, 0x18426, // 740
+            0x139d0, 0x118c8, 0x18c66, 0x17bd0, 0x139c8, 0x19ce6, 0x10842, 0x17bc8, 0x1bde6, 0x118c2, // 750
+            0x17bc4, 0x1086c, 0x118ec, 0x10866, 0x139ec, 0x118e6, 0x17bec, 0x139e6, 0x17be6, 0x1ef28, // 760
+            0x1f796, 0x1ef24, 0x1ef22, 0x1ce28, 0x1e716, 0x1de68, 0x1ef36, 0x1de64, 0x1ce22, 0x1de62, // 770
+            0x18c28, 0x1c616, 0x19c68, 0x18c24, 0x1bce8, 0x19c64, 0x18c22, 0x1bce4, 0x19c62, 0x1bce2, // 780
+            0x10828, 0x18416, 0x11868, 0x18c36, 0x138e8, 0x11864, 0x10822, 0x179e8, 0x138e4, 0x11862, // 790
+            0x179e4, 0x138e2, 0x179e2, 0x11876, 0x179f6, 0x1ef12, 0x1de34, 0x1de32, 0x19c34, 0x1bc74, // 800
+            0x1bc72, 0x11834, 0x13874, 0x178f4, 0x178f2, 0x10540, 0x10520, 0x18298, 0x10510, 0x10508, // 810
+            0x10504, 0x105b0, 0x10598, 0x1058c, 0x10586, 0x105dc, 0x105ce, 0x186a0, 0x18690, 0x1c34c, // 820
+            0x18688, 0x1c346, 0x18684, 0x18682, 0x104a0, 0x18258, 0x10da0, 0x186d8, 0x1824c, 0x10d90, // 830
+            0x186cc, 0x10d88, 0x186c6, 0x10d84, 0x10482, 0x10d82, 0x104d8, 0x1826e, 0x10dd8, 0x186ee, // 840
+            0x10dcc, 0x104c6, 0x10dc6, 0x104ee, 0x10dee, 0x1c750, 0x1c748, 0x1c744, 0x1c742, 0x18650, // 850
+            0x18ed0, 0x1c76c, 0x1c326, 0x18ec8, 0x1c766, 0x18ec4, 0x18642, 0x18ec2, 0x10450, 0x10cd0, // 860
+            0x10448, 0x18226, 0x11dd0, 0x10cc8, 0x10444, 0x11dc8, 0x10cc4, 0x10442, 0x11dc4, 0x10cc2, // 870
+            0x1046c, 0x10cec, 0x10466, 0x11dec, 0x10ce6, 0x11de6, 0x1e7a8, 0x1e7a4, 0x1e7a2, 0x1c728, // 880
+            0x1cf68, 0x1e7b6, 0x1cf64, 0x1c722, 0x1cf62, 0x18628, 0x1c316, 0x18e68, 0x1c736, 0x19ee8, // 890
+            0x18e64, 0x18622, 0x19ee4, 0x18e62, 0x19ee2, 0x10428, 0x18216, 0x10c68, 0x18636, 0x11ce8, // 900
+            0x10c64, 0x10422, 0x13de8, 0x11ce4, 0x10c62, 0x13de4, 0x11ce2, 0x10436, 0x10c76, 0x11cf6, // 910
+            0x13df6, 0x1f7d4, 0x1f7d2, 0x1e794, 0x1efb4, 0x1e792, 0x1efb2, 0x1c714, 0x1cf34, 0x1c712, // 920
+            0x1df74, 0x1cf32, 0x1df72, 0x18614, 0x18e34, 0x18612, 0x19e74, 0x18e32, 0x1bef4), // 929
+        array(// cluster 3 -----------------------------------------------------------------------
+            0x1f560, 0x1fab8, 0x1ea40, 0x1f530, 0x1fa9c, 0x1ea20, 0x1f518, 0x1fa8e, 0x1ea10, 0x1f50c, //  10
+            0x1ea08, 0x1f506, 0x1ea04, 0x1eb60, 0x1f5b8, 0x1fade, 0x1d640, 0x1eb30, 0x1f59c, 0x1d620, //  20
+            0x1eb18, 0x1f58e, 0x1d610, 0x1eb0c, 0x1d608, 0x1eb06, 0x1d604, 0x1d760, 0x1ebb8, 0x1f5de, //  30
+            0x1ae40, 0x1d730, 0x1eb9c, 0x1ae20, 0x1d718, 0x1eb8e, 0x1ae10, 0x1d70c, 0x1ae08, 0x1d706, //  40
+            0x1ae04, 0x1af60, 0x1d7b8, 0x1ebde, 0x15e40, 0x1af30, 0x1d79c, 0x15e20, 0x1af18, 0x1d78e, //  50
+            0x15e10, 0x1af0c, 0x15e08, 0x1af06, 0x15f60, 0x1afb8, 0x1d7de, 0x15f30, 0x1af9c, 0x15f18, //  60
+            0x1af8e, 0x15f0c, 0x15fb8, 0x1afde, 0x15f9c, 0x15f8e, 0x1e940, 0x1f4b0, 0x1fa5c, 0x1e920, //  70
+            0x1f498, 0x1fa4e, 0x1e910, 0x1f48c, 0x1e908, 0x1f486, 0x1e904, 0x1e902, 0x1d340, 0x1e9b0, //  80
+            0x1f4dc, 0x1d320, 0x1e998, 0x1f4ce, 0x1d310, 0x1e98c, 0x1d308, 0x1e986, 0x1d304, 0x1d302, //  90
+            0x1a740, 0x1d3b0, 0x1e9dc, 0x1a720, 0x1d398, 0x1e9ce, 0x1a710, 0x1d38c, 0x1a708, 0x1d386, // 100
+            0x1a704, 0x1a702, 0x14f40, 0x1a7b0, 0x1d3dc, 0x14f20, 0x1a798, 0x1d3ce, 0x14f10, 0x1a78c, // 110
+            0x14f08, 0x1a786, 0x14f04, 0x14fb0, 0x1a7dc, 0x14f98, 0x1a7ce, 0x14f8c, 0x14f86, 0x14fdc, // 120
+            0x14fce, 0x1e8a0, 0x1f458, 0x1fa2e, 0x1e890, 0x1f44c, 0x1e888, 0x1f446, 0x1e884, 0x1e882, // 130
+            0x1d1a0, 0x1e8d8, 0x1f46e, 0x1d190, 0x1e8cc, 0x1d188, 0x1e8c6, 0x1d184, 0x1d182, 0x1a3a0, // 140
+            0x1d1d8, 0x1e8ee, 0x1a390, 0x1d1cc, 0x1a388, 0x1d1c6, 0x1a384, 0x1a382, 0x147a0, 0x1a3d8, // 150
+            0x1d1ee, 0x14790, 0x1a3cc, 0x14788, 0x1a3c6, 0x14784, 0x14782, 0x147d8, 0x1a3ee, 0x147cc, // 160
+            0x147c6, 0x147ee, 0x1e850, 0x1f42c, 0x1e848, 0x1f426, 0x1e844, 0x1e842, 0x1d0d0, 0x1e86c, // 170
+            0x1d0c8, 0x1e866, 0x1d0c4, 0x1d0c2, 0x1a1d0, 0x1d0ec, 0x1a1c8, 0x1d0e6, 0x1a1c4, 0x1a1c2, // 180
+            0x143d0, 0x1a1ec, 0x143c8, 0x1a1e6, 0x143c4, 0x143c2, 0x143ec, 0x143e6, 0x1e828, 0x1f416, // 190
+            0x1e824, 0x1e822, 0x1d068, 0x1e836, 0x1d064, 0x1d062, 0x1a0e8, 0x1d076, 0x1a0e4, 0x1a0e2, // 200
+            0x141e8, 0x1a0f6, 0x141e4, 0x141e2, 0x1e814, 0x1e812, 0x1d034, 0x1d032, 0x1a074, 0x1a072, // 210
+            0x1e540, 0x1f2b0, 0x1f95c, 0x1e520, 0x1f298, 0x1f94e, 0x1e510, 0x1f28c, 0x1e508, 0x1f286, // 220
+            0x1e504, 0x1e502, 0x1cb40, 0x1e5b0, 0x1f2dc, 0x1cb20, 0x1e598, 0x1f2ce, 0x1cb10, 0x1e58c, // 230
+            0x1cb08, 0x1e586, 0x1cb04, 0x1cb02, 0x19740, 0x1cbb0, 0x1e5dc, 0x19720, 0x1cb98, 0x1e5ce, // 240
+            0x19710, 0x1cb8c, 0x19708, 0x1cb86, 0x19704, 0x19702, 0x12f40, 0x197b0, 0x1cbdc, 0x12f20, // 250
+            0x19798, 0x1cbce, 0x12f10, 0x1978c, 0x12f08, 0x19786, 0x12f04, 0x12fb0, 0x197dc, 0x12f98, // 260
+            0x197ce, 0x12f8c, 0x12f86, 0x12fdc, 0x12fce, 0x1f6a0, 0x1fb58, 0x16bf0, 0x1f690, 0x1fb4c, // 270
+            0x169f8, 0x1f688, 0x1fb46, 0x168fc, 0x1f684, 0x1f682, 0x1e4a0, 0x1f258, 0x1f92e, 0x1eda0, // 280
+            0x1e490, 0x1fb6e, 0x1ed90, 0x1f6cc, 0x1f246, 0x1ed88, 0x1e484, 0x1ed84, 0x1e482, 0x1ed82, // 290
+            0x1c9a0, 0x1e4d8, 0x1f26e, 0x1dba0, 0x1c990, 0x1e4cc, 0x1db90, 0x1edcc, 0x1e4c6, 0x1db88, // 300
+            0x1c984, 0x1db84, 0x1c982, 0x1db82, 0x193a0, 0x1c9d8, 0x1e4ee, 0x1b7a0, 0x19390, 0x1c9cc, // 310
+            0x1b790, 0x1dbcc, 0x1c9c6, 0x1b788, 0x19384, 0x1b784, 0x19382, 0x1b782, 0x127a0, 0x193d8, // 320
+            0x1c9ee, 0x16fa0, 0x12790, 0x193cc, 0x16f90, 0x1b7cc, 0x193c6, 0x16f88, 0x12784, 0x16f84, // 330
+            0x12782, 0x127d8, 0x193ee, 0x16fd8, 0x127cc, 0x16fcc, 0x127c6, 0x16fc6, 0x127ee, 0x1f650, // 340
+            0x1fb2c, 0x165f8, 0x1f648, 0x1fb26, 0x164fc, 0x1f644, 0x1647e, 0x1f642, 0x1e450, 0x1f22c, // 350
+            0x1ecd0, 0x1e448, 0x1f226, 0x1ecc8, 0x1f666, 0x1ecc4, 0x1e442, 0x1ecc2, 0x1c8d0, 0x1e46c, // 360
+            0x1d9d0, 0x1c8c8, 0x1e466, 0x1d9c8, 0x1ece6, 0x1d9c4, 0x1c8c2, 0x1d9c2, 0x191d0, 0x1c8ec, // 370
+            0x1b3d0, 0x191c8, 0x1c8e6, 0x1b3c8, 0x1d9e6, 0x1b3c4, 0x191c2, 0x1b3c2, 0x123d0, 0x191ec, // 380
+            0x167d0, 0x123c8, 0x191e6, 0x167c8, 0x1b3e6, 0x167c4, 0x123c2, 0x167c2, 0x123ec, 0x167ec, // 390
+            0x123e6, 0x167e6, 0x1f628, 0x1fb16, 0x162fc, 0x1f624, 0x1627e, 0x1f622, 0x1e428, 0x1f216, // 400
+            0x1ec68, 0x1f636, 0x1ec64, 0x1e422, 0x1ec62, 0x1c868, 0x1e436, 0x1d8e8, 0x1c864, 0x1d8e4, // 410
+            0x1c862, 0x1d8e2, 0x190e8, 0x1c876, 0x1b1e8, 0x1d8f6, 0x1b1e4, 0x190e2, 0x1b1e2, 0x121e8, // 420
+            0x190f6, 0x163e8, 0x121e4, 0x163e4, 0x121e2, 0x163e2, 0x121f6, 0x163f6, 0x1f614, 0x1617e, // 430
+            0x1f612, 0x1e414, 0x1ec34, 0x1e412, 0x1ec32, 0x1c834, 0x1d874, 0x1c832, 0x1d872, 0x19074, // 440
+            0x1b0f4, 0x19072, 0x1b0f2, 0x120f4, 0x161f4, 0x120f2, 0x161f2, 0x1f60a, 0x1e40a, 0x1ec1a, // 450
+            0x1c81a, 0x1d83a, 0x1903a, 0x1b07a, 0x1e2a0, 0x1f158, 0x1f8ae, 0x1e290, 0x1f14c, 0x1e288, // 460
+            0x1f146, 0x1e284, 0x1e282, 0x1c5a0, 0x1e2d8, 0x1f16e, 0x1c590, 0x1e2cc, 0x1c588, 0x1e2c6, // 470
+            0x1c584, 0x1c582, 0x18ba0, 0x1c5d8, 0x1e2ee, 0x18b90, 0x1c5cc, 0x18b88, 0x1c5c6, 0x18b84, // 480
+            0x18b82, 0x117a0, 0x18bd8, 0x1c5ee, 0x11790, 0x18bcc, 0x11788, 0x18bc6, 0x11784, 0x11782, // 490
+            0x117d8, 0x18bee, 0x117cc, 0x117c6, 0x117ee, 0x1f350, 0x1f9ac, 0x135f8, 0x1f348, 0x1f9a6, // 500
+            0x134fc, 0x1f344, 0x1347e, 0x1f342, 0x1e250, 0x1f12c, 0x1e6d0, 0x1e248, 0x1f126, 0x1e6c8, // 510
+            0x1f366, 0x1e6c4, 0x1e242, 0x1e6c2, 0x1c4d0, 0x1e26c, 0x1cdd0, 0x1c4c8, 0x1e266, 0x1cdc8, // 520
+            0x1e6e6, 0x1cdc4, 0x1c4c2, 0x1cdc2, 0x189d0, 0x1c4ec, 0x19bd0, 0x189c8, 0x1c4e6, 0x19bc8, // 530
+            0x1cde6, 0x19bc4, 0x189c2, 0x19bc2, 0x113d0, 0x189ec, 0x137d0, 0x113c8, 0x189e6, 0x137c8, // 540
+            0x19be6, 0x137c4, 0x113c2, 0x137c2, 0x113ec, 0x137ec, 0x113e6, 0x137e6, 0x1fba8, 0x175f0, // 550
+            0x1bafc, 0x1fba4, 0x174f8, 0x1ba7e, 0x1fba2, 0x1747c, 0x1743e, 0x1f328, 0x1f996, 0x132fc, // 560
+            0x1f768, 0x1fbb6, 0x176fc, 0x1327e, 0x1f764, 0x1f322, 0x1767e, 0x1f762, 0x1e228, 0x1f116, // 570
+            0x1e668, 0x1e224, 0x1eee8, 0x1f776, 0x1e222, 0x1eee4, 0x1e662, 0x1eee2, 0x1c468, 0x1e236, // 580
+            0x1cce8, 0x1c464, 0x1dde8, 0x1cce4, 0x1c462, 0x1dde4, 0x1cce2, 0x1dde2, 0x188e8, 0x1c476, // 590
+            0x199e8, 0x188e4, 0x1bbe8, 0x199e4, 0x188e2, 0x1bbe4, 0x199e2, 0x1bbe2, 0x111e8, 0x188f6, // 600
+            0x133e8, 0x111e4, 0x177e8, 0x133e4, 0x111e2, 0x177e4, 0x133e2, 0x177e2, 0x111f6, 0x133f6, // 610
+            0x1fb94, 0x172f8, 0x1b97e, 0x1fb92, 0x1727c, 0x1723e, 0x1f314, 0x1317e, 0x1f734, 0x1f312, // 620
+            0x1737e, 0x1f732, 0x1e214, 0x1e634, 0x1e212, 0x1ee74, 0x1e632, 0x1ee72, 0x1c434, 0x1cc74, // 630
+            0x1c432, 0x1dcf4, 0x1cc72, 0x1dcf2, 0x18874, 0x198f4, 0x18872, 0x1b9f4, 0x198f2, 0x1b9f2, // 640
+            0x110f4, 0x131f4, 0x110f2, 0x173f4, 0x131f2, 0x173f2, 0x1fb8a, 0x1717c, 0x1713e, 0x1f30a, // 650
+            0x1f71a, 0x1e20a, 0x1e61a, 0x1ee3a, 0x1c41a, 0x1cc3a, 0x1dc7a, 0x1883a, 0x1987a, 0x1b8fa, // 660
+            0x1107a, 0x130fa, 0x171fa, 0x170be, 0x1e150, 0x1f0ac, 0x1e148, 0x1f0a6, 0x1e144, 0x1e142, // 670
+            0x1c2d0, 0x1e16c, 0x1c2c8, 0x1e166, 0x1c2c4, 0x1c2c2, 0x185d0, 0x1c2ec, 0x185c8, 0x1c2e6, // 680
+            0x185c4, 0x185c2, 0x10bd0, 0x185ec, 0x10bc8, 0x185e6, 0x10bc4, 0x10bc2, 0x10bec, 0x10be6, // 690
+            0x1f1a8, 0x1f8d6, 0x11afc, 0x1f1a4, 0x11a7e, 0x1f1a2, 0x1e128, 0x1f096, 0x1e368, 0x1e124, // 700
+            0x1e364, 0x1e122, 0x1e362, 0x1c268, 0x1e136, 0x1c6e8, 0x1c264, 0x1c6e4, 0x1c262, 0x1c6e2, // 710
+            0x184e8, 0x1c276, 0x18de8, 0x184e4, 0x18de4, 0x184e2, 0x18de2, 0x109e8, 0x184f6, 0x11be8, // 720
+            0x109e4, 0x11be4, 0x109e2, 0x11be2, 0x109f6, 0x11bf6, 0x1f9d4, 0x13af8, 0x19d7e, 0x1f9d2, // 730
+            0x13a7c, 0x13a3e, 0x1f194, 0x1197e, 0x1f3b4, 0x1f192, 0x13b7e, 0x1f3b2, 0x1e114, 0x1e334, // 740
+            0x1e112, 0x1e774, 0x1e332, 0x1e772, 0x1c234, 0x1c674, 0x1c232, 0x1cef4, 0x1c672, 0x1cef2, // 750
+            0x18474, 0x18cf4, 0x18472, 0x19df4, 0x18cf2, 0x19df2, 0x108f4, 0x119f4, 0x108f2, 0x13bf4, // 760
+            0x119f2, 0x13bf2, 0x17af0, 0x1bd7c, 0x17a78, 0x1bd3e, 0x17a3c, 0x17a1e, 0x1f9ca, 0x1397c, // 770
+            0x1fbda, 0x17b7c, 0x1393e, 0x17b3e, 0x1f18a, 0x1f39a, 0x1f7ba, 0x1e10a, 0x1e31a, 0x1e73a, // 780
+            0x1ef7a, 0x1c21a, 0x1c63a, 0x1ce7a, 0x1defa, 0x1843a, 0x18c7a, 0x19cfa, 0x1bdfa, 0x1087a, // 790
+            0x118fa, 0x139fa, 0x17978, 0x1bcbe, 0x1793c, 0x1791e, 0x138be, 0x179be, 0x178bc, 0x1789e, // 800
+            0x1785e, 0x1e0a8, 0x1e0a4, 0x1e0a2, 0x1c168, 0x1e0b6, 0x1c164, 0x1c162, 0x182e8, 0x1c176, // 810
+            0x182e4, 0x182e2, 0x105e8, 0x182f6, 0x105e4, 0x105e2, 0x105f6, 0x1f0d4, 0x10d7e, 0x1f0d2, // 820
+            0x1e094, 0x1e1b4, 0x1e092, 0x1e1b2, 0x1c134, 0x1c374, 0x1c132, 0x1c372, 0x18274, 0x186f4, // 830
+            0x18272, 0x186f2, 0x104f4, 0x10df4, 0x104f2, 0x10df2, 0x1f8ea, 0x11d7c, 0x11d3e, 0x1f0ca, // 840
+            0x1f1da, 0x1e08a, 0x1e19a, 0x1e3ba, 0x1c11a, 0x1c33a, 0x1c77a, 0x1823a, 0x1867a, 0x18efa, // 850
+            0x1047a, 0x10cfa, 0x11dfa, 0x13d78, 0x19ebe, 0x13d3c, 0x13d1e, 0x11cbe, 0x13dbe, 0x17d70, // 860
+            0x1bebc, 0x17d38, 0x1be9e, 0x17d1c, 0x17d0e, 0x13cbc, 0x17dbc, 0x13c9e, 0x17d9e, 0x17cb8, // 870
+            0x1be5e, 0x17c9c, 0x17c8e, 0x13c5e, 0x17cde, 0x17c5c, 0x17c4e, 0x17c2e, 0x1c0b4, 0x1c0b2, // 880
+            0x18174, 0x18172, 0x102f4, 0x102f2, 0x1e0da, 0x1c09a, 0x1c1ba, 0x1813a, 0x1837a, 0x1027a, // 890
+            0x106fa, 0x10ebe, 0x11ebc, 0x11e9e, 0x13eb8, 0x19f5e, 0x13e9c, 0x13e8e, 0x11e5e, 0x13ede, // 900
+            0x17eb0, 0x1bf5c, 0x17e98, 0x1bf4e, 0x17e8c, 0x17e86, 0x13e5c, 0x17edc, 0x13e4e, 0x17ece, // 910
+            0x17e58, 0x1bf2e, 0x17e4c, 0x17e46, 0x13e2e, 0x17e6e, 0x17e2c, 0x17e26, 0x10f5e, 0x11f5c, // 920
+            0x11f4e, 0x13f58, 0x19fae, 0x13f4c, 0x13f46, 0x11f2e, 0x13f6e, 0x13f2c, 0x13f26), // 929
+        array(// cluster 6 -----------------------------------------------------------------------
+            0x1abe0, 0x1d5f8, 0x153c0, 0x1a9f0, 0x1d4fc, 0x151e0, 0x1a8f8, 0x1d47e, 0x150f0, 0x1a87c, //  10
+            0x15078, 0x1fad0, 0x15be0, 0x1adf8, 0x1fac8, 0x159f0, 0x1acfc, 0x1fac4, 0x158f8, 0x1ac7e, //  20
+            0x1fac2, 0x1587c, 0x1f5d0, 0x1faec, 0x15df8, 0x1f5c8, 0x1fae6, 0x15cfc, 0x1f5c4, 0x15c7e, //  30
+            0x1f5c2, 0x1ebd0, 0x1f5ec, 0x1ebc8, 0x1f5e6, 0x1ebc4, 0x1ebc2, 0x1d7d0, 0x1ebec, 0x1d7c8, //  40
+            0x1ebe6, 0x1d7c4, 0x1d7c2, 0x1afd0, 0x1d7ec, 0x1afc8, 0x1d7e6, 0x1afc4, 0x14bc0, 0x1a5f0, //  50
+            0x1d2fc, 0x149e0, 0x1a4f8, 0x1d27e, 0x148f0, 0x1a47c, 0x14878, 0x1a43e, 0x1483c, 0x1fa68, //  60
+            0x14df0, 0x1a6fc, 0x1fa64, 0x14cf8, 0x1a67e, 0x1fa62, 0x14c7c, 0x14c3e, 0x1f4e8, 0x1fa76, //  70
+            0x14efc, 0x1f4e4, 0x14e7e, 0x1f4e2, 0x1e9e8, 0x1f4f6, 0x1e9e4, 0x1e9e2, 0x1d3e8, 0x1e9f6, //  80
+            0x1d3e4, 0x1d3e2, 0x1a7e8, 0x1d3f6, 0x1a7e4, 0x1a7e2, 0x145e0, 0x1a2f8, 0x1d17e, 0x144f0, //  90
+            0x1a27c, 0x14478, 0x1a23e, 0x1443c, 0x1441e, 0x1fa34, 0x146f8, 0x1a37e, 0x1fa32, 0x1467c, // 100
+            0x1463e, 0x1f474, 0x1477e, 0x1f472, 0x1e8f4, 0x1e8f2, 0x1d1f4, 0x1d1f2, 0x1a3f4, 0x1a3f2, // 110
+            0x142f0, 0x1a17c, 0x14278, 0x1a13e, 0x1423c, 0x1421e, 0x1fa1a, 0x1437c, 0x1433e, 0x1f43a, // 120
+            0x1e87a, 0x1d0fa, 0x14178, 0x1a0be, 0x1413c, 0x1411e, 0x141be, 0x140bc, 0x1409e, 0x12bc0, // 130
+            0x195f0, 0x1cafc, 0x129e0, 0x194f8, 0x1ca7e, 0x128f0, 0x1947c, 0x12878, 0x1943e, 0x1283c, // 140
+            0x1f968, 0x12df0, 0x196fc, 0x1f964, 0x12cf8, 0x1967e, 0x1f962, 0x12c7c, 0x12c3e, 0x1f2e8, // 150
+            0x1f976, 0x12efc, 0x1f2e4, 0x12e7e, 0x1f2e2, 0x1e5e8, 0x1f2f6, 0x1e5e4, 0x1e5e2, 0x1cbe8, // 160
+            0x1e5f6, 0x1cbe4, 0x1cbe2, 0x197e8, 0x1cbf6, 0x197e4, 0x197e2, 0x1b5e0, 0x1daf8, 0x1ed7e, // 170
+            0x169c0, 0x1b4f0, 0x1da7c, 0x168e0, 0x1b478, 0x1da3e, 0x16870, 0x1b43c, 0x16838, 0x1b41e, // 180
+            0x1681c, 0x125e0, 0x192f8, 0x1c97e, 0x16de0, 0x124f0, 0x1927c, 0x16cf0, 0x1b67c, 0x1923e, // 190
+            0x16c78, 0x1243c, 0x16c3c, 0x1241e, 0x16c1e, 0x1f934, 0x126f8, 0x1937e, 0x1fb74, 0x1f932, // 200
+            0x16ef8, 0x1267c, 0x1fb72, 0x16e7c, 0x1263e, 0x16e3e, 0x1f274, 0x1277e, 0x1f6f4, 0x1f272, // 210
+            0x16f7e, 0x1f6f2, 0x1e4f4, 0x1edf4, 0x1e4f2, 0x1edf2, 0x1c9f4, 0x1dbf4, 0x1c9f2, 0x1dbf2, // 220
+            0x193f4, 0x193f2, 0x165c0, 0x1b2f0, 0x1d97c, 0x164e0, 0x1b278, 0x1d93e, 0x16470, 0x1b23c, // 230
+            0x16438, 0x1b21e, 0x1641c, 0x1640e, 0x122f0, 0x1917c, 0x166f0, 0x12278, 0x1913e, 0x16678, // 240
+            0x1b33e, 0x1663c, 0x1221e, 0x1661e, 0x1f91a, 0x1237c, 0x1fb3a, 0x1677c, 0x1233e, 0x1673e, // 250
+            0x1f23a, 0x1f67a, 0x1e47a, 0x1ecfa, 0x1c8fa, 0x1d9fa, 0x191fa, 0x162e0, 0x1b178, 0x1d8be, // 260
+            0x16270, 0x1b13c, 0x16238, 0x1b11e, 0x1621c, 0x1620e, 0x12178, 0x190be, 0x16378, 0x1213c, // 270
+            0x1633c, 0x1211e, 0x1631e, 0x121be, 0x163be, 0x16170, 0x1b0bc, 0x16138, 0x1b09e, 0x1611c, // 280
+            0x1610e, 0x120bc, 0x161bc, 0x1209e, 0x1619e, 0x160b8, 0x1b05e, 0x1609c, 0x1608e, 0x1205e, // 290
+            0x160de, 0x1605c, 0x1604e, 0x115e0, 0x18af8, 0x1c57e, 0x114f0, 0x18a7c, 0x11478, 0x18a3e, // 300
+            0x1143c, 0x1141e, 0x1f8b4, 0x116f8, 0x18b7e, 0x1f8b2, 0x1167c, 0x1163e, 0x1f174, 0x1177e, // 310
+            0x1f172, 0x1e2f4, 0x1e2f2, 0x1c5f4, 0x1c5f2, 0x18bf4, 0x18bf2, 0x135c0, 0x19af0, 0x1cd7c, // 320
+            0x134e0, 0x19a78, 0x1cd3e, 0x13470, 0x19a3c, 0x13438, 0x19a1e, 0x1341c, 0x1340e, 0x112f0, // 330
+            0x1897c, 0x136f0, 0x11278, 0x1893e, 0x13678, 0x19b3e, 0x1363c, 0x1121e, 0x1361e, 0x1f89a, // 340
+            0x1137c, 0x1f9ba, 0x1377c, 0x1133e, 0x1373e, 0x1f13a, 0x1f37a, 0x1e27a, 0x1e6fa, 0x1c4fa, // 350
+            0x1cdfa, 0x189fa, 0x1bae0, 0x1dd78, 0x1eebe, 0x174c0, 0x1ba70, 0x1dd3c, 0x17460, 0x1ba38, // 360
+            0x1dd1e, 0x17430, 0x1ba1c, 0x17418, 0x1ba0e, 0x1740c, 0x132e0, 0x19978, 0x1ccbe, 0x176e0, // 370
+            0x13270, 0x1993c, 0x17670, 0x1bb3c, 0x1991e, 0x17638, 0x1321c, 0x1761c, 0x1320e, 0x1760e, // 380
+            0x11178, 0x188be, 0x13378, 0x1113c, 0x17778, 0x1333c, 0x1111e, 0x1773c, 0x1331e, 0x1771e, // 390
+            0x111be, 0x133be, 0x177be, 0x172c0, 0x1b970, 0x1dcbc, 0x17260, 0x1b938, 0x1dc9e, 0x17230, // 400
+            0x1b91c, 0x17218, 0x1b90e, 0x1720c, 0x17206, 0x13170, 0x198bc, 0x17370, 0x13138, 0x1989e, // 410
+            0x17338, 0x1b99e, 0x1731c, 0x1310e, 0x1730e, 0x110bc, 0x131bc, 0x1109e, 0x173bc, 0x1319e, // 420
+            0x1739e, 0x17160, 0x1b8b8, 0x1dc5e, 0x17130, 0x1b89c, 0x17118, 0x1b88e, 0x1710c, 0x17106, // 430
+            0x130b8, 0x1985e, 0x171b8, 0x1309c, 0x1719c, 0x1308e, 0x1718e, 0x1105e, 0x130de, 0x171de, // 440
+            0x170b0, 0x1b85c, 0x17098, 0x1b84e, 0x1708c, 0x17086, 0x1305c, 0x170dc, 0x1304e, 0x170ce, // 450
+            0x17058, 0x1b82e, 0x1704c, 0x17046, 0x1302e, 0x1706e, 0x1702c, 0x17026, 0x10af0, 0x1857c, // 460
+            0x10a78, 0x1853e, 0x10a3c, 0x10a1e, 0x10b7c, 0x10b3e, 0x1f0ba, 0x1e17a, 0x1c2fa, 0x185fa, // 470
+            0x11ae0, 0x18d78, 0x1c6be, 0x11a70, 0x18d3c, 0x11a38, 0x18d1e, 0x11a1c, 0x11a0e, 0x10978, // 480
+            0x184be, 0x11b78, 0x1093c, 0x11b3c, 0x1091e, 0x11b1e, 0x109be, 0x11bbe, 0x13ac0, 0x19d70, // 490
+            0x1cebc, 0x13a60, 0x19d38, 0x1ce9e, 0x13a30, 0x19d1c, 0x13a18, 0x19d0e, 0x13a0c, 0x13a06, // 500
+            0x11970, 0x18cbc, 0x13b70, 0x11938, 0x18c9e, 0x13b38, 0x1191c, 0x13b1c, 0x1190e, 0x13b0e, // 510
+            0x108bc, 0x119bc, 0x1089e, 0x13bbc, 0x1199e, 0x13b9e, 0x1bd60, 0x1deb8, 0x1ef5e, 0x17a40, // 520
+            0x1bd30, 0x1de9c, 0x17a20, 0x1bd18, 0x1de8e, 0x17a10, 0x1bd0c, 0x17a08, 0x1bd06, 0x17a04, // 530
+            0x13960, 0x19cb8, 0x1ce5e, 0x17b60, 0x13930, 0x19c9c, 0x17b30, 0x1bd9c, 0x19c8e, 0x17b18, // 540
+            0x1390c, 0x17b0c, 0x13906, 0x17b06, 0x118b8, 0x18c5e, 0x139b8, 0x1189c, 0x17bb8, 0x1399c, // 550
+            0x1188e, 0x17b9c, 0x1398e, 0x17b8e, 0x1085e, 0x118de, 0x139de, 0x17bde, 0x17940, 0x1bcb0, // 560
+            0x1de5c, 0x17920, 0x1bc98, 0x1de4e, 0x17910, 0x1bc8c, 0x17908, 0x1bc86, 0x17904, 0x17902, // 570
+            0x138b0, 0x19c5c, 0x179b0, 0x13898, 0x19c4e, 0x17998, 0x1bcce, 0x1798c, 0x13886, 0x17986, // 580
+            0x1185c, 0x138dc, 0x1184e, 0x179dc, 0x138ce, 0x179ce, 0x178a0, 0x1bc58, 0x1de2e, 0x17890, // 590
+            0x1bc4c, 0x17888, 0x1bc46, 0x17884, 0x17882, 0x13858, 0x19c2e, 0x178d8, 0x1384c, 0x178cc, // 600
+            0x13846, 0x178c6, 0x1182e, 0x1386e, 0x178ee, 0x17850, 0x1bc2c, 0x17848, 0x1bc26, 0x17844, // 610
+            0x17842, 0x1382c, 0x1786c, 0x13826, 0x17866, 0x17828, 0x1bc16, 0x17824, 0x17822, 0x13816, // 620
+            0x17836, 0x10578, 0x182be, 0x1053c, 0x1051e, 0x105be, 0x10d70, 0x186bc, 0x10d38, 0x1869e, // 630
+            0x10d1c, 0x10d0e, 0x104bc, 0x10dbc, 0x1049e, 0x10d9e, 0x11d60, 0x18eb8, 0x1c75e, 0x11d30, // 640
+            0x18e9c, 0x11d18, 0x18e8e, 0x11d0c, 0x11d06, 0x10cb8, 0x1865e, 0x11db8, 0x10c9c, 0x11d9c, // 650
+            0x10c8e, 0x11d8e, 0x1045e, 0x10cde, 0x11dde, 0x13d40, 0x19eb0, 0x1cf5c, 0x13d20, 0x19e98, // 660
+            0x1cf4e, 0x13d10, 0x19e8c, 0x13d08, 0x19e86, 0x13d04, 0x13d02, 0x11cb0, 0x18e5c, 0x13db0, // 670
+            0x11c98, 0x18e4e, 0x13d98, 0x19ece, 0x13d8c, 0x11c86, 0x13d86, 0x10c5c, 0x11cdc, 0x10c4e, // 680
+            0x13ddc, 0x11cce, 0x13dce, 0x1bea0, 0x1df58, 0x1efae, 0x1be90, 0x1df4c, 0x1be88, 0x1df46, // 690
+            0x1be84, 0x1be82, 0x13ca0, 0x19e58, 0x1cf2e, 0x17da0, 0x13c90, 0x19e4c, 0x17d90, 0x1becc, // 700
+            0x19e46, 0x17d88, 0x13c84, 0x17d84, 0x13c82, 0x17d82, 0x11c58, 0x18e2e, 0x13cd8, 0x11c4c, // 710
+            0x17dd8, 0x13ccc, 0x11c46, 0x17dcc, 0x13cc6, 0x17dc6, 0x10c2e, 0x11c6e, 0x13cee, 0x17dee, // 720
+            0x1be50, 0x1df2c, 0x1be48, 0x1df26, 0x1be44, 0x1be42, 0x13c50, 0x19e2c, 0x17cd0, 0x13c48, // 730
+            0x19e26, 0x17cc8, 0x1be66, 0x17cc4, 0x13c42, 0x17cc2, 0x11c2c, 0x13c6c, 0x11c26, 0x17cec, // 740
+            0x13c66, 0x17ce6, 0x1be28, 0x1df16, 0x1be24, 0x1be22, 0x13c28, 0x19e16, 0x17c68, 0x13c24, // 750
+            0x17c64, 0x13c22, 0x17c62, 0x11c16, 0x13c36, 0x17c76, 0x1be14, 0x1be12, 0x13c14, 0x17c34, // 760
+            0x13c12, 0x17c32, 0x102bc, 0x1029e, 0x106b8, 0x1835e, 0x1069c, 0x1068e, 0x1025e, 0x106de, // 770
+            0x10eb0, 0x1875c, 0x10e98, 0x1874e, 0x10e8c, 0x10e86, 0x1065c, 0x10edc, 0x1064e, 0x10ece, // 780
+            0x11ea0, 0x18f58, 0x1c7ae, 0x11e90, 0x18f4c, 0x11e88, 0x18f46, 0x11e84, 0x11e82, 0x10e58, // 790
+            0x1872e, 0x11ed8, 0x18f6e, 0x11ecc, 0x10e46, 0x11ec6, 0x1062e, 0x10e6e, 0x11eee, 0x19f50, // 800
+            0x1cfac, 0x19f48, 0x1cfa6, 0x19f44, 0x19f42, 0x11e50, 0x18f2c, 0x13ed0, 0x19f6c, 0x18f26, // 810
+            0x13ec8, 0x11e44, 0x13ec4, 0x11e42, 0x13ec2, 0x10e2c, 0x11e6c, 0x10e26, 0x13eec, 0x11e66, // 820
+            0x13ee6, 0x1dfa8, 0x1efd6, 0x1dfa4, 0x1dfa2, 0x19f28, 0x1cf96, 0x1bf68, 0x19f24, 0x1bf64, // 830
+            0x19f22, 0x1bf62, 0x11e28, 0x18f16, 0x13e68, 0x11e24, 0x17ee8, 0x13e64, 0x11e22, 0x17ee4, // 840
+            0x13e62, 0x17ee2, 0x10e16, 0x11e36, 0x13e76, 0x17ef6, 0x1df94, 0x1df92, 0x19f14, 0x1bf34, // 850
+            0x19f12, 0x1bf32, 0x11e14, 0x13e34, 0x11e12, 0x17e74, 0x13e32, 0x17e72, 0x1df8a, 0x19f0a, // 860
+            0x1bf1a, 0x11e0a, 0x13e1a, 0x17e3a, 0x1035c, 0x1034e, 0x10758, 0x183ae, 0x1074c, 0x10746, // 870
+            0x1032e, 0x1076e, 0x10f50, 0x187ac, 0x10f48, 0x187a6, 0x10f44, 0x10f42, 0x1072c, 0x10f6c, // 880
+            0x10726, 0x10f66, 0x18fa8, 0x1c7d6, 0x18fa4, 0x18fa2, 0x10f28, 0x18796, 0x11f68, 0x18fb6, // 890
+            0x11f64, 0x10f22, 0x11f62, 0x10716, 0x10f36, 0x11f76, 0x1cfd4, 0x1cfd2, 0x18f94, 0x19fb4, // 900
+            0x18f92, 0x19fb2, 0x10f14, 0x11f34, 0x10f12, 0x13f74, 0x11f32, 0x13f72, 0x1cfca, 0x18f8a, // 910
+            0x19f9a, 0x10f0a, 0x11f1a, 0x13f3a, 0x103ac, 0x103a6, 0x107a8, 0x183d6, 0x107a4, 0x107a2, // 920
+            0x10396, 0x107b6, 0x187d4, 0x187d2, 0x10794, 0x10fb4, 0x10792, 0x10fb2, 0x1c7ea)         // 929
+    ); // end of $clusters array
+
+    /**
+     * Array of factors of the Reed-Solomon polynomial equations used for error correction; one sub array for each correction level (0-8).
+     * @protected
+     */
+    protected $rsfactors = array(
+        array(// ECL 0 (2 factors) -------------------------------------------------------------------------------
+            0x01b, 0x395), //   2
+        array(// ECL 1 (4 factors) -------------------------------------------------------------------------------
+            0x20a, 0x238, 0x2d3, 0x329), //   4
+        array(// ECL 2 (8 factors) -------------------------------------------------------------------------------
+            0x0ed, 0x134, 0x1b4, 0x11c, 0x286, 0x28d, 0x1ac, 0x17b), //   8
+        array(// ECL 3 (16 factors) ------------------------------------------------------------------------------
+            0x112, 0x232, 0x0e8, 0x2f3, 0x257, 0x20c, 0x321, 0x084, 0x127, 0x074, 0x1ba, 0x1ac, 0x127, 0x02a, 0x0b0, 0x041), //  16
+        array(// ECL 4 (32 factors) ------------------------------------------------------------------------------
+            0x169, 0x23f, 0x39a, 0x20d, 0x0b0, 0x24a, 0x280, 0x141, 0x218, 0x2e6, 0x2a5, 0x2e6, 0x2af, 0x11c, 0x0c1, 0x205, //  16
+            0x111, 0x1ee, 0x107, 0x093, 0x251, 0x320, 0x23b, 0x140, 0x323, 0x085, 0x0e7, 0x186, 0x2ad, 0x14a, 0x03f, 0x19a), //  32
+        array(// ECL 5 (64 factors) ------------------------------------------------------------------------------
+            0x21b, 0x1a6, 0x006, 0x05d, 0x35e, 0x303, 0x1c5, 0x06a, 0x262, 0x11f, 0x06b, 0x1f9, 0x2dd, 0x36d, 0x17d, 0x264, //  16
+            0x2d3, 0x1dc, 0x1ce, 0x0ac, 0x1ae, 0x261, 0x35a, 0x336, 0x21f, 0x178, 0x1ff, 0x190, 0x2a0, 0x2fa, 0x11b, 0x0b8, //  32
+            0x1b8, 0x023, 0x207, 0x01f, 0x1cc, 0x252, 0x0e1, 0x217, 0x205, 0x160, 0x25d, 0x09e, 0x28b, 0x0c9, 0x1e8, 0x1f6, //  48
+            0x288, 0x2dd, 0x2cd, 0x053, 0x194, 0x061, 0x118, 0x303, 0x348, 0x275, 0x004, 0x17d, 0x34b, 0x26f, 0x108, 0x21f), //  64
+        array(// ECL 6 (128 factors) -----------------------------------------------------------------------------
+            0x209, 0x136, 0x360, 0x223, 0x35a, 0x244, 0x128, 0x17b, 0x035, 0x30b, 0x381, 0x1bc, 0x190, 0x39d, 0x2ed, 0x19f, //  16
+            0x336, 0x05d, 0x0d9, 0x0d0, 0x3a0, 0x0f4, 0x247, 0x26c, 0x0f6, 0x094, 0x1bf, 0x277, 0x124, 0x38c, 0x1ea, 0x2c0, //  32
+            0x204, 0x102, 0x1c9, 0x38b, 0x252, 0x2d3, 0x2a2, 0x124, 0x110, 0x060, 0x2ac, 0x1b0, 0x2ae, 0x25e, 0x35c, 0x239, //  48
+            0x0c1, 0x0db, 0x081, 0x0ba, 0x0ec, 0x11f, 0x0c0, 0x307, 0x116, 0x0ad, 0x028, 0x17b, 0x2c8, 0x1cf, 0x286, 0x308, //  64
+            0x0ab, 0x1eb, 0x129, 0x2fb, 0x09c, 0x2dc, 0x05f, 0x10e, 0x1bf, 0x05a, 0x1fb, 0x030, 0x0e4, 0x335, 0x328, 0x382, //  80
+            0x310, 0x297, 0x273, 0x17a, 0x17e, 0x106, 0x17c, 0x25a, 0x2f2, 0x150, 0x059, 0x266, 0x057, 0x1b0, 0x29e, 0x268, //  96
+            0x09d, 0x176, 0x0f2, 0x2d6, 0x258, 0x10d, 0x177, 0x382, 0x34d, 0x1c6, 0x162, 0x082, 0x32e, 0x24b, 0x324, 0x022, // 112
+            0x0d3, 0x14a, 0x21b, 0x129, 0x33b, 0x361, 0x025, 0x205, 0x342, 0x13b, 0x226, 0x056, 0x321, 0x004, 0x06c, 0x21b), // 128
+        array(// ECL 7 (256 factors) -----------------------------------------------------------------------------
+            0x20c, 0x37e, 0x04b, 0x2fe, 0x372, 0x359, 0x04a, 0x0cc, 0x052, 0x24a, 0x2c4, 0x0fa, 0x389, 0x312, 0x08a, 0x2d0, //  16
+            0x35a, 0x0c2, 0x137, 0x391, 0x113, 0x0be, 0x177, 0x352, 0x1b6, 0x2dd, 0x0c2, 0x118, 0x0c9, 0x118, 0x33c, 0x2f5, //  32
+            0x2c6, 0x32e, 0x397, 0x059, 0x044, 0x239, 0x00b, 0x0cc, 0x31c, 0x25d, 0x21c, 0x391, 0x321, 0x2bc, 0x31f, 0x089, //  48
+            0x1b7, 0x1a2, 0x250, 0x29c, 0x161, 0x35b, 0x172, 0x2b6, 0x145, 0x0f0, 0x0d8, 0x101, 0x11c, 0x225, 0x0d1, 0x374, //  64
+            0x13b, 0x046, 0x149, 0x319, 0x1ea, 0x112, 0x36d, 0x0a2, 0x2ed, 0x32c, 0x2ac, 0x1cd, 0x14e, 0x178, 0x351, 0x209, //  80
+            0x133, 0x123, 0x323, 0x2c8, 0x013, 0x166, 0x18f, 0x38c, 0x067, 0x1ff, 0x033, 0x008, 0x205, 0x0e1, 0x121, 0x1d6, //  96
+            0x27d, 0x2db, 0x042, 0x0ff, 0x395, 0x10d, 0x1cf, 0x33e, 0x2da, 0x1b1, 0x350, 0x249, 0x088, 0x21a, 0x38a, 0x05a, // 112
+            0x002, 0x122, 0x2e7, 0x0c7, 0x28f, 0x387, 0x149, 0x031, 0x322, 0x244, 0x163, 0x24c, 0x0bc, 0x1ce, 0x00a, 0x086, // 128
+            0x274, 0x140, 0x1df, 0x082, 0x2e3, 0x047, 0x107, 0x13e, 0x176, 0x259, 0x0c0, 0x25d, 0x08e, 0x2a1, 0x2af, 0x0ea, // 144
+            0x2d2, 0x180, 0x0b1, 0x2f0, 0x25f, 0x280, 0x1c7, 0x0c1, 0x2b1, 0x2c3, 0x325, 0x281, 0x030, 0x03c, 0x2dc, 0x26d, // 160
+            0x37f, 0x220, 0x105, 0x354, 0x28f, 0x135, 0x2b9, 0x2f3, 0x2f4, 0x03c, 0x0e7, 0x305, 0x1b2, 0x1a5, 0x2d6, 0x210, // 176
+            0x1f7, 0x076, 0x031, 0x31b, 0x020, 0x090, 0x1f4, 0x0ee, 0x344, 0x18a, 0x118, 0x236, 0x13f, 0x009, 0x287, 0x226, // 192
+            0x049, 0x392, 0x156, 0x07e, 0x020, 0x2a9, 0x14b, 0x318, 0x26c, 0x03c, 0x261, 0x1b9, 0x0b4, 0x317, 0x37d, 0x2f2, // 208
+            0x25d, 0x17f, 0x0e4, 0x2ed, 0x2f8, 0x0d5, 0x036, 0x129, 0x086, 0x036, 0x342, 0x12b, 0x39a, 0x0bf, 0x38e, 0x214, // 224
+            0x261, 0x33d, 0x0bd, 0x014, 0x0a7, 0x01d, 0x368, 0x1c1, 0x053, 0x192, 0x029, 0x290, 0x1f9, 0x243, 0x1e1, 0x0ad, // 240
+            0x194, 0x0fb, 0x2b0, 0x05f, 0x1f1, 0x22b, 0x282, 0x21f, 0x133, 0x09f, 0x39c, 0x22e, 0x288, 0x037, 0x1f1, 0x00a), // 256
+        array(// ECL 8 (512 factors) -----------------------------------------------------------------------------
+            0x160, 0x04d, 0x175, 0x1f8, 0x023, 0x257, 0x1ac, 0x0cf, 0x199, 0x23e, 0x076, 0x1f2, 0x11d, 0x17c, 0x15e, 0x1ec, //  16
+            0x0c5, 0x109, 0x398, 0x09b, 0x392, 0x12b, 0x0e5, 0x283, 0x126, 0x367, 0x132, 0x058, 0x057, 0x0c1, 0x160, 0x30d, //  32
+            0x34e, 0x04b, 0x147, 0x208, 0x1b3, 0x21f, 0x0cb, 0x29a, 0x0f9, 0x15a, 0x30d, 0x26d, 0x280, 0x10c, 0x31a, 0x216, //  48
+            0x21b, 0x30d, 0x198, 0x186, 0x284, 0x066, 0x1dc, 0x1f3, 0x122, 0x278, 0x221, 0x025, 0x35a, 0x394, 0x228, 0x029, //  64
+            0x21e, 0x121, 0x07a, 0x110, 0x17f, 0x320, 0x1e5, 0x062, 0x2f0, 0x1d8, 0x2f9, 0x06b, 0x310, 0x35c, 0x292, 0x2e5, //  80
+            0x122, 0x0cc, 0x2a9, 0x197, 0x357, 0x055, 0x063, 0x03e, 0x1e2, 0x0b4, 0x014, 0x129, 0x1c3, 0x251, 0x391, 0x08e, //  96
+            0x328, 0x2ac, 0x11f, 0x218, 0x231, 0x04c, 0x28d, 0x383, 0x2d9, 0x237, 0x2e8, 0x186, 0x201, 0x0c0, 0x204, 0x102, // 112
+            0x0f0, 0x206, 0x31a, 0x18b, 0x300, 0x350, 0x033, 0x262, 0x180, 0x0a8, 0x0be, 0x33a, 0x148, 0x254, 0x312, 0x12f, // 128
+            0x23a, 0x17d, 0x19f, 0x281, 0x09c, 0x0ed, 0x097, 0x1ad, 0x213, 0x0cf, 0x2a4, 0x2c6, 0x059, 0x0a8, 0x130, 0x192, // 144
+            0x028, 0x2c4, 0x23f, 0x0a2, 0x360, 0x0e5, 0x041, 0x35d, 0x349, 0x200, 0x0a4, 0x1dd, 0x0dd, 0x05c, 0x166, 0x311, // 160
+            0x120, 0x165, 0x352, 0x344, 0x33b, 0x2e0, 0x2c3, 0x05e, 0x008, 0x1ee, 0x072, 0x209, 0x002, 0x1f3, 0x353, 0x21f, // 176
+            0x098, 0x2d9, 0x303, 0x05f, 0x0f8, 0x169, 0x242, 0x143, 0x358, 0x31d, 0x121, 0x033, 0x2ac, 0x1d2, 0x215, 0x334, // 192
+            0x29d, 0x02d, 0x386, 0x1c4, 0x0a7, 0x156, 0x0f4, 0x0ad, 0x023, 0x1cf, 0x28b, 0x033, 0x2bb, 0x24f, 0x1c4, 0x242, // 208
+            0x025, 0x07c, 0x12a, 0x14c, 0x228, 0x02b, 0x1ab, 0x077, 0x296, 0x309, 0x1db, 0x352, 0x2fc, 0x16c, 0x242, 0x38f, // 224
+            0x11b, 0x2c7, 0x1d8, 0x1a4, 0x0f5, 0x120, 0x252, 0x18a, 0x1ff, 0x147, 0x24d, 0x309, 0x2bb, 0x2b0, 0x02b, 0x198, // 240
+            0x34a, 0x17f, 0x2d1, 0x209, 0x230, 0x284, 0x2ca, 0x22f, 0x03e, 0x091, 0x369, 0x297, 0x2c9, 0x09f, 0x2a0, 0x2d9, // 256
+            0x270, 0x03b, 0x0c1, 0x1a1, 0x09e, 0x0d1, 0x233, 0x234, 0x157, 0x2b5, 0x06d, 0x260, 0x233, 0x16d, 0x0b5, 0x304, // 272
+            0x2a5, 0x136, 0x0f8, 0x161, 0x2c4, 0x19a, 0x243, 0x366, 0x269, 0x349, 0x278, 0x35c, 0x121, 0x218, 0x023, 0x309, // 288
+            0x26a, 0x24a, 0x1a8, 0x341, 0x04d, 0x255, 0x15a, 0x10d, 0x2f5, 0x278, 0x2b7, 0x2ef, 0x14b, 0x0f7, 0x0b8, 0x02d, // 304
+            0x313, 0x2a8, 0x012, 0x042, 0x197, 0x171, 0x036, 0x1ec, 0x0e4, 0x265, 0x33e, 0x39a, 0x1b5, 0x207, 0x284, 0x389, // 320
+            0x315, 0x1a4, 0x131, 0x1b9, 0x0cf, 0x12c, 0x37c, 0x33b, 0x08d, 0x219, 0x17d, 0x296, 0x201, 0x038, 0x0fc, 0x155, // 336
+            0x0f2, 0x31d, 0x346, 0x345, 0x2d0, 0x0e0, 0x133, 0x277, 0x03d, 0x057, 0x230, 0x136, 0x2f4, 0x299, 0x18d, 0x328, // 352
+            0x353, 0x135, 0x1d9, 0x31b, 0x17a, 0x01f, 0x287, 0x393, 0x1cb, 0x326, 0x24e, 0x2db, 0x1a9, 0x0d8, 0x224, 0x0f9, // 368
+            0x141, 0x371, 0x2bb, 0x217, 0x2a1, 0x30e, 0x0d2, 0x32f, 0x389, 0x12f, 0x34b, 0x39a, 0x119, 0x049, 0x1d5, 0x317, // 384
+            0x294, 0x0a2, 0x1f2, 0x134, 0x09b, 0x1a6, 0x38b, 0x331, 0x0bb, 0x03e, 0x010, 0x1a9, 0x217, 0x150, 0x11e, 0x1b5, // 400
+            0x177, 0x111, 0x262, 0x128, 0x0b7, 0x39b, 0x074, 0x29b, 0x2ef, 0x161, 0x03e, 0x16e, 0x2b3, 0x17b, 0x2af, 0x34a, // 416
+            0x025, 0x165, 0x2d0, 0x2e6, 0x14a, 0x005, 0x027, 0x39b, 0x137, 0x1a8, 0x0f2, 0x2ed, 0x141, 0x036, 0x29d, 0x13c, // 432
+            0x156, 0x12b, 0x216, 0x069, 0x29b, 0x1e8, 0x280, 0x2a0, 0x240, 0x21c, 0x13c, 0x1e6, 0x2d1, 0x262, 0x02e, 0x290, // 448
+            0x1bf, 0x0ab, 0x268, 0x1d0, 0x0be, 0x213, 0x129, 0x141, 0x2fa, 0x2f0, 0x215, 0x0af, 0x086, 0x00e, 0x17d, 0x1b1, // 464
+            0x2cd, 0x02d, 0x06f, 0x014, 0x254, 0x11c, 0x2e0, 0x08a, 0x286, 0x19b, 0x36d, 0x29d, 0x08d, 0x397, 0x02d, 0x30c, // 480
+            0x197, 0x0a4, 0x14c, 0x383, 0x0a5, 0x2d6, 0x258, 0x145, 0x1f2, 0x28f, 0x165, 0x2f0, 0x300, 0x0df, 0x351, 0x287, // 496
+            0x03f, 0x136, 0x35f, 0x0fb, 0x16e, 0x130, 0x11a, 0x2e2, 0x2a3, 0x19a, 0x185, 0x0f4, 0x01f, 0x079, 0x12f, 0x107) // 512
+    );
+
+    /**
+     * This is the class constructor.
+     * Creates a PDF417 object
+     * @param $code (string) code to represent using PDF417
+     * @param $ecl (int) error correction level (0-8); default -1 = automatic correction level
+     * @param $aspectratio (float) the width to height of the symbol (excluding quiet zones)
+     * @param $macro (array) information for macro block
+     * @public
+     */
+    public function __construct($code, $ecl = -1, $aspectratio = 2, $macro = array()) {
+        $barcode_array = array();
+        if ((is_null($code)) OR ($code == '\0') OR ($code == '')) {
+            return false;
+        }
+        // get the input sequence array
+        $sequence = $this->getInputSequences($code);
+        $codewords = array(); // array of code-words
+        foreach ($sequence as $seq) {
+            $cw = $this->getCompaction($seq[0], $seq[1], true);
+            $codewords = array_merge($codewords, $cw);
+        }
+        if ($codewords[0] == 900) {
+            // Text Alpha is the default mode, so remove the first code
+            array_shift($codewords);
+        }
+        // count number of codewords
+        $numcw = count($codewords);
+        if ($numcw > 925) {
+            // reached maximum data codeword capacity
+            return false;
+        }
+        // build macro control block codewords
+        if (!empty($macro)) {
+            $macrocw = array();
+            // beginning of macro control block
+            $macrocw[] = 928;
+            // segment index
+            $cw = $this->getCompaction(902, sprintf('%05d', $macro['segment_index']), false);
+            $macrocw = array_merge($macrocw, $cw);
+            // file ID
+            $cw = $this->getCompaction(900, $macro['file_id'], false);
+            $macrocw = array_merge($macrocw, $cw);
+            // optional fields
+            $optmodes = array(900, 902, 902, 900, 900, 902, 902);
+            $optsize = array(-1, 2, 4, -1, -1, -1, 2);
+            foreach ($optmodes as $k => $omode) {
+                if (isset($macro['option_' . $k])) {
+                    $macrocw[] = 923;
+                    $macrocw[] = $k;
+                    if ($optsize[$k] == 2) {
+                        $macro['option_' . $k] = sprintf('%05d', $macro['option_' . $k]);
+                    } elseif ($optsize[$k] == 4) {
+                        $macro['option_' . $k] = sprintf('%010d', $macro['option_' . $k]);
+                    }
+                    $cw = $this->getCompaction($omode, $macro['option_' . $k], false);
+                    $macrocw = array_merge($macrocw, $cw);
+                }
+            }
+            if ($macro['segment_index'] == ($macro['segment_total'] - 1)) {
+                // end of control block
+                $macrocw[] = 922;
+            }
+            // update total codewords
+            $numcw += count($macrocw);
+        }
+        // set error correction level
+        $ecl = $this->getErrorCorrectionLevel($ecl, $numcw);
+        // number of codewords for error correction
+        $errsize = (2 << $ecl);
+        // calculate number of columns (number of codewords per row) and rows
+        $nce = ($numcw + $errsize + 1);
+        $cols = round((sqrt(4761 + (68 * $aspectratio * ROWHEIGHT * $nce)) - 69) / 34);
+        // adjust cols
+        if ($cols < 1) {
+            $cols = 1;
+        } elseif ($cols > 30) {
+            $cols = 30;
+        }
+        $rows = ceil($nce / $cols);
+        $size = ($cols * $rows);
+        // adjust rows
+        if (($rows < 3) OR ($rows > 90)) {
+            if ($rows < 3) {
+                $rows = 3;
+            } elseif ($rows > 90) {
+                $rows = 90;
+            }
+            $cols = ceil($size / $rows);
+            $size = ($cols * $rows);
+        }
+        if ($size > 928) {
+            // set dimensions to get maximum capacity
+            if (abs($aspectratio - (17 * 29 / 32)) < abs($aspectratio - (17 * 16 / 58))) {
+                $cols = 29;
+                $rows = 32;
+            } else {
+                $cols = 16;
+                $rows = 58;
+            }
+            $size = 928;
+        }
+        // calculate padding
+        $pad = ($size - $nce);
+        if ($pad > 0) {
+            if (($size - $rows) == $nce) {
+                --$rows;
+                $size -= $rows;
+            } else {
+                // add pading
+                $codewords = array_merge($codewords, array_fill(0, $pad, 900));
+            }
+        }
+        if (!empty($macro)) {
+            // add macro section
+            $codewords = array_merge($codewords, $macrocw);
+        }
+        // Symbol Lenght Descriptor (number of data codewords including Symbol Lenght Descriptor and pad codewords)
+        $sld = $size - $errsize;
+        // add symbol length description
+        array_unshift($codewords, $sld);
+        // calculate error correction
+        $ecw = $this->getErrorCorrection($codewords, $ecl);
+        // add error correction codewords
+        $codewords = array_merge($codewords, $ecw);
+        // add horizontal quiet zones to start and stop patterns
+        $pstart = str_repeat('0', QUIETH) . $this->start_pattern;
+        $pstop = $this->stop_pattern . str_repeat('0', QUIETH);
+        $barcode_array['num_rows'] = ($rows * ROWHEIGHT) + (2 * QUIETV);
+        $barcode_array['num_cols'] = (($cols + 2) * 17) + 35 + (2 * QUIETH);
+        $barcode_array['bcode'] = array();
+        // build rows for vertical quiet zone
+        if (QUIETV > 0) {
+            $empty_row = array_fill(0, $barcode_array['num_cols'], 0);
+            for ($i = 0; $i < QUIETV; ++$i) {
+                // add vertical quiet rows
+                $barcode_array['bcode'][] = $empty_row;
+            }
+        }
+        $k = 0; // codeword index
+        $cid = 0; // initial cluster
+        // for each row
+        for ($r = 0; $r < $rows; ++$r) {
+            // row start code
+            $row = $pstart;
+            switch ($cid) {
+                case 0: {
+                        $L = ((30 * intval($r / 3)) + intval(($rows - 1) / 3));
+                        break;
+                    }
+                case 1: {
+                        $L = ((30 * intval($r / 3)) + ($ecl * 3) + (($rows - 1) % 3));
+                        break;
+                    }
+                case 2: {
+                        $L = ((30 * intval($r / 3)) + ($cols - 1));
+                        break;
+                    }
+            }
+            // left row indicator
+            $row .= sprintf('%17b', $this->clusters[$cid][$L]);
+            // for each column
+            for ($c = 0; $c < $cols; ++$c) {
+                $row .= sprintf('%17b', $this->clusters[$cid][$codewords[$k]]);
+                ++$k;
+            }
+            switch ($cid) {
+                case 0: {
+                        $L = ((30 * intval($r / 3)) + ($cols - 1));
+                        break;
+                    }
+                case 1: {
+                        $L = ((30 * intval($r / 3)) + intval(($rows - 1) / 3));
+                        break;
+                    }
+                case 2: {
+                        $L = ((30 * intval($r / 3)) + ($ecl * 3) + (($rows - 1) % 3));
+                        break;
+                    }
+            }
+            // right row indicator
+            $row .= sprintf('%17b', $this->clusters[$cid][$L]);
+            // row stop code
+            $row .= $pstop;
+            // convert the string to array
+            $arow = preg_split('//', $row, -1, PREG_SPLIT_NO_EMPTY);
+            // duplicate row to get the desired height
+            for ($h = 0; $h < ROWHEIGHT; ++$h) {
+                $barcode_array['bcode'][] = $arow;
+            }
+            ++$cid;
+            if ($cid > 2) {
+                $cid = 0;
+            }
+        }
+        if (QUIETV > 0) {
+            for ($i = 0; $i < QUIETV; ++$i) {
+                // add vertical quiet rows
+                $barcode_array['bcode'][] = $empty_row;
+            }
+        }
+        $this->barcode_array = $barcode_array;
+    }
+
+    /**
+     * Returns a barcode array which is readable by Dinesh Rabara
+     * @return array barcode array readable by Dinesh Rabara;
+     * @public
+     */
+    public function getBarcodeArray() {
+        return $this->barcode_array;
+    }
+
+    /**
+     * Returns the error correction level (0-8) to be used
+     * @param $ecl (int) error correction level
+     * @param $numcw (int) number of data codewords
+     * @return int error correction level
+     * @protected
+     */
+    protected function getErrorCorrectionLevel($ecl, $numcw) {
+        // get maximum correction level
+        $maxecl = 8; // starting error level
+        $maxerrsize = (928 - $numcw); // available codewords for error
+        while ($maxecl > 0) {
+            $errsize = (2 << $ecl);
+            if ($maxerrsize >= $errsize) {
+                break;
+            }
+            --$maxecl;
+        }
+        // check for automatic levels
+        if (($ecl < 0) OR ($ecl > 8)) {
+            if ($numcw < 41) {
+                $ecl = 2;
+            } elseif ($numcw < 161) {
+                $ecl = 3;
+            } elseif ($numcw < 321) {
+                $ecl = 4;
+            } elseif ($numcw < 864) {
+                $ecl = 5;
+            } else {
+                $ecl = $maxecl;
+            }
+        }
+        if ($ecl > $maxecl) {
+            $ecl = $maxecl;
+        }
+        return $ecl;
+    }
+
+    /**
+     * Returns the error correction codewords
+     * @param $cw (array) array of codewords including Symbol Lenght Descriptor and pad
+     * @param $ecl (int) error correction level 0-8
+     * @return array of error correction codewords
+     * @protected
+     */
+    protected function getErrorCorrection($cw, $ecl) {
+        // get error correction coefficients
+        $ecc = $this->rsfactors[$ecl];
+        // number of error correction factors
+        $eclsize = (2 << $ecl);
+        // maximum index for $rsfactors[$ecl]
+        $eclmaxid = ($eclsize - 1);
+        // initialize array of error correction codewords
+        $ecw = array_fill(0, $eclsize, 0);
+        // for each data codeword
+        foreach ($cw as $k => $d) {
+            $t1 = ($d + $ecw[$eclmaxid]) % 929;
+            for ($j = $eclmaxid; $j > 0; --$j) {
+                $t2 = ($t1 * $ecc[$j]) % 929;
+                $t3 = 929 - $t2;
+                $ecw[$j] = ($ecw[($j - 1)] + $t3) % 929;
+            }
+            $t2 = ($t1 * $ecc[0]) % 929;
+            $t3 = 929 - $t2;
+            $ecw[0] = $t3 % 929;
+        }
+        foreach ($ecw as $j => $e) {
+            if ($e != 0) {
+                $ecw[$j] = 929 - $e;
+            }
+        }
+        $ecw = array_reverse($ecw);
+        return $ecw;
+    }
+
+    /**
+     * Create array of sequences from input
+     * @param $code (string) code
+     * @return bidimensional array containing characters and classification
+     * @protected
+     */
+    protected function getInputSequences($code) {
+        $sequence_array = array(); // array to be returned
+        $numseq = array();
+        // get numeric sequences
+        preg_match_all('/([0-9]{13,})/', $code, $numseq, PREG_OFFSET_CAPTURE);
+        $numseq[1][] = array('', strlen($code));
+        $offset = 0;
+        foreach ($numseq[1] as $seq) {
+            $seqlen = strlen($seq[0]);
+            if ($seq[1] > 0) {
+                // extract text sequence before the number sequence
+                $prevseq = substr($code, $offset, ($seq[1] - $offset));
+                $textseq = array();
+                // get text sequences
+                preg_match_all('/([\x09\x0a\x0d\x20-\x7e]{5,})/', $prevseq, $textseq, PREG_OFFSET_CAPTURE);
+                $textseq[1][] = array('', strlen($prevseq));
+                $txtoffset = 0;
+                foreach ($textseq[1] as $txtseq) {
+                    $txtseqlen = strlen($txtseq[0]);
+                    if ($txtseq[1] > 0) {
+                        // extract byte sequence before the text sequence
+                        $prevtxtseq = substr($prevseq, $txtoffset, ($txtseq[1] - $txtoffset));
+                        if (strlen($prevtxtseq) > 0) {
+                            // add BYTE sequence
+                            if ((strlen($prevtxtseq) == 1) AND ((count($sequence_array) > 0) AND ($sequence_array[(count($sequence_array) - 1)][0] == 900))) {
+                                $sequence_array[] = array(913, $prevtxtseq);
+                            } elseif ((strlen($prevtxtseq) % 6) == 0) {
+                                $sequence_array[] = array(924, $prevtxtseq);
+                            } else {
+                                $sequence_array[] = array(901, $prevtxtseq);
+                            }
+                        }
+                    }
+                    if ($txtseqlen > 0) {
+                        // add numeric sequence
+                        $sequence_array[] = array(900, $txtseq[0]);
+                    }
+                    $txtoffset = $txtseq[1] + $txtseqlen;
+                }
+            }
+            if ($seqlen > 0) {
+                // add numeric sequence
+                $sequence_array[] = array(902, $seq[0]);
+            }
+            $offset = $seq[1] + $seqlen;
+        }
+        return $sequence_array;
+    }
+
+    /**
+     * Compact data by mode.
+     * @param $mode (int) compaction mode number
+     * @param $code (string) data to compact
+     * @param $addmode (boolean) if true add the mode codeword at first position
+     * @return array of codewords
+     * @protected
+     */
+    protected function getCompaction($mode, $code, $addmode = true) {
+        $cw = array(); // array of codewords to return
+        switch ($mode) {
+            case 900: { // Text Compaction mode latch
+                    $submode = 0; // default Alpha sub-mode
+                    $txtarr = array(); // array of characters and sub-mode switching characters
+                    $codelen = strlen($code);
+                    for ($i = 0; $i < $codelen; ++$i) {
+                        $chval = ord($code{$i});
+                        if (($k = array_search($chval, $this->textsubmodes[$submode])) !== false) {
+                            // we are on the same sub-mode
+                            $txtarr[] = $k;
+                        } else {
+                            // the sub-mode is changed
+                            for ($s = 0; $s < 4; ++$s) {
+                                // search new sub-mode
+                                if (($s != $submode) AND (($k = array_search($chval, $this->textsubmodes[$s])) !== false)) {
+                                    // $s is the new submode
+                                    if (((($i + 1) == $codelen) OR ((($i + 1) < $codelen) AND (array_search(ord($code{($i + 1)}), $this->textsubmodes[$submode]) !== false))) AND (($s == 3) OR (($s == 0) AND ($submode == 1)))) {
+                                        // shift (temporary change only for this char)
+                                        if ($s == 3) {
+                                            // shift to puntuaction
+                                            $txtarr[] = 29;
+                                        } else {
+                                            // shift from lower to alpha
+                                            $txtarr[] = 27;
+                                        }
+                                    } else {
+                                        // latch
+                                        $txtarr = array_merge($txtarr, $this->textlatch['' . $submode . $s]);
+                                        // set new submode
+                                        $submode = $s;
+                                    }
+                                    // add characted code to array
+                                    $txtarr[] = $k;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    $txtarrlen = count($txtarr);
+                    if (($txtarrlen % 2) != 0) {
+                        // add padding
+                        $txtarr[] = 29;
+                        ++$txtarrlen;
+                    }
+                    // calculate codewords
+                    for ($i = 0; $i < $txtarrlen; $i += 2) {
+                        $cw[] = (30 * $txtarr[$i]) + $txtarr[($i + 1)];
+                    }
+                    break;
+                }
+            case 901:
+            case 924: { // Byte Compaction mode latch
+                    while (($codelen = strlen($code)) > 0) {
+                        if ($codelen > 6) {
+                            $rest = substr($code, 6);
+                            $code = substr($code, 0, 6);
+                            $sublen = 6;
+                        } else {
+                            $rest = '';
+                            $sublen = strlen($code);
+                        }
+                        if ($sublen == 6) {
+                            $t = bcmul('' . ord($code{0}), '1099511627776');
+                            $t = bcadd($t, bcmul('' . ord($code{1}), '4294967296'));
+                            $t = bcadd($t, bcmul('' . ord($code{2}), '16777216'));
+                            $t = bcadd($t, bcmul('' . ord($code{3}), '65536'));
+                            $t = bcadd($t, bcmul('' . ord($code{4}), '256'));
+                            $t = bcadd($t, '' . ord($code{5}));
+                            do {
+                                $d = bcmod($t, '900');
+                                $t = bcdiv($t, '900');
+                                array_unshift($cw, $d);
+                            } while ($t != '0');
+                        } else {
+                            for ($i = 0; $i < $sublen; ++$i) {
+                                $cw[] = ord($code{$i});
+                            }
+                        }
+                        $code = $rest;
+                    }
+                    break;
+                }
+            case 902: { // Numeric Compaction mode latch
+                    while (($codelen = strlen($code)) > 0) {
+                        if ($codelen > 44) {
+                            $rest = substr($code, 44);
+                            $code = substr($code, 0, 44);
+                        } else {
+                            $rest = '';
+                        }
+                        $t = '1' . $code;
+                        do {
+                            $d = bcmod($t, '900');
+                            $t = bcdiv($t, '900');
+                            array_unshift($cw, $d);
+                        } while ($t != '0');
+                        $code = $rest;
+                    }
+                    break;
+                }
+            case 913: { // Byte Compaction mode shift
+                    $cw[] = ord($code);
+                    break;
+                }
+        }
+        if ($addmode) {
+            // add the compaction mode codeword at the beginning
+            array_unshift($cw, $mode);
+        }
+        return $cw;
+    }
+
+}
+
+// end PDF417 class
+
+//============================================================+
+// END OF FILE
+//============================================================+

vendor/milon/barcode/src/Milon/Barcode/QRcode.php

+<?php 
+
+namespace Milon\Barcode;
+
+//============================================================+
+// File name   : qrcode.php
+// Version     : 1.0.010
+// Begin       : 2010-03-22
+// Last Update : 2012-07-25
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2010-2012 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <http://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// DESCRIPTION :
+//
+// Class to create QR-code arrays for TCPDF class.
+// QR Code symbol is a 2D barcode that can be scanned by
+// handy terminals such as a mobile phone with CCD.
+// The capacity of QR Code is up to 7000 digits or 4000
+// characters, and has high robustness.
+// This class supports QR Code model 2, described in
+// JIS (Japanese Industrial Standards) X0510:2004
+// or ISO/IEC 18004.
+// Currently the following features are not supported:
+// ECI and FNC1 mode, Micro QR Code, QR Code model 1,
+// Structured mode.
+//
+// This class is derived from the following projects:
+// ---------------------------------------------------------
+// "PHP QR Code encoder"
+// License: GNU-LGPLv3
+// Copyright (C) 2010 by Dominik Dzienia <deltalab at poczta dot fm>
+// http://phpqrcode.sourceforge.net/
+// https://sourceforge.net/projects/phpqrcode/
+//
+// The "PHP QR Code encoder" is based on
+// "C libqrencode library" (ver. 3.1.1)
+// License: GNU-LGPL 2.1
+// Copyright (C) 2006-2010 by Kentaro Fukuchi
+// http://megaui.net/fukuchi/works/qrencode/index.en.html
+//
+// Reed-Solomon code encoder is written by Phil Karn, KA9Q.
+// Copyright (C) 2002-2006 Phil Karn, KA9Q
+//
+// QR Code is registered trademark of DENSO WAVE INCORPORATED
+// http://www.denso-wave.com/qrcode/index-e.html
+// ---------------------------------------------------------
+//============================================================+
+/**
+ * @file
+ * Class to create QR-code arrays for TCPDF class.
+ * QR Code symbol is a 2D barcode that can be scanned by handy terminals such as a mobile phone with CCD.
+ * The capacity of QR Code is up to 7000 digits or 4000 characters, and has high robustness.
+ * This class supports QR Code model 2, described in JIS (Japanese Industrial Standards) X0510:2004 or ISO/IEC 18004.
+ * Currently the following features are not supported: ECI and FNC1 mode, Micro QR Code, QR Code model 1, Structured mode.
+ *
+ * This class is derived from "PHP QR Code encoder" by Dominik Dzienia (http://phpqrcode.sourceforge.net/) based on "libqrencode C library 3.1.1." by Kentaro Fukuchi (http://megaui.net/fukuchi/works/qrencode/index.en.html), contains Reed-Solomon code written by Phil Karn, KA9Q. QR Code is registered trademark of DENSO WAVE INCORPORATED (http://www.denso-wave.com/qrcode/index-e.html).
+ * Please read comments on this class source file for full copyright and license information.
+ *
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.010
+ */
+
+// definitions
+if (!defined('QRCODEDEFS')) {
+
+    /**
+     * Indicate that definitions for this class are set
+     */
+    define('QRCODEDEFS', true);
+
+    // -----------------------------------------------------
+    // Encoding modes (characters which can be encoded in QRcode)
+
+    /**
+     * Encoding mode
+     */
+    define('QR_MODE_NL', -1);
+
+    /**
+     * Encoding mode numeric (0-9). 3 characters are encoded to 10bit length. In theory, 7089 characters or less can be stored in a QRcode.
+     */
+    define('QR_MODE_NM', 0);
+
+    /**
+     * Encoding mode alphanumeric (0-9A-Z $%*+-./:) 45characters. 2 characters are encoded to 11bit length. In theory, 4296 characters or less can be stored in a QRcode.
+     */
+    define('QR_MODE_AN', 1);
+
+    /**
+     * Encoding mode 8bit byte data. In theory, 2953 characters or less can be stored in a QRcode.
+     */
+    define('QR_MODE_8B', 2);
+
+    /**
+     * Encoding mode KANJI. A KANJI character (multibyte character) is encoded to 13bit length. In theory, 1817 characters or less can be stored in a QRcode.
+     */
+    define('QR_MODE_KJ', 3);
+
+    /**
+     * Encoding mode STRUCTURED (currently unsupported)
+     */
+    define('QR_MODE_ST', 4);
+
+    // -----------------------------------------------------
+    // Levels of error correction.
+    // QRcode has a function of an error correcting for miss reading that white is black.
+    // Error correcting is defined in 4 level as below.
+
+    /**
+     * Error correction level L : About 7% or less errors can be corrected.
+     */
+    define('QR_ECLEVEL_L', 0);
+
+    /**
+     * Error correction level M : About 15% or less errors can be corrected.
+     */
+    define('QR_ECLEVEL_M', 1);
+
+    /**
+     * Error correction level Q : About 25% or less errors can be corrected.
+     */
+    define('QR_ECLEVEL_Q', 2);
+
+    /**
+     * Error correction level H : About 30% or less errors can be corrected.
+     */
+    define('QR_ECLEVEL_H', 3);
+
+    // -----------------------------------------------------
+    // Version. Size of QRcode is defined as version.
+    // Version is from 1 to 40.
+    // Version 1 is 21*21 matrix. And 4 modules increases whenever 1 version increases.
+    // So version 40 is 177*177 matrix.
+
+    /**
+     * Maximum QR Code version.
+     */
+    define('QRSPEC_VERSION_MAX', 40);
+
+    /**
+     * Maximum matrix size for maximum version (version 40 is 177*177 matrix).
+     */
+    define('QRSPEC_WIDTH_MAX', 177);
+
+    // -----------------------------------------------------
+
+    /**
+     * Matrix index to get width from $capacity array.
+     */
+    define('QRCAP_WIDTH', 0);
+
+    /**
+     * Matrix index to get number of words from $capacity array.
+     */
+    define('QRCAP_WORDS', 1);
+
+    /**
+     * Matrix index to get remainder from $capacity array.
+     */
+    define('QRCAP_REMINDER', 2);
+
+    /**
+     * Matrix index to get error correction level from $capacity array.
+     */
+    define('QRCAP_EC', 3);
+
+    // -----------------------------------------------------
+    // Structure (currently usupported)
+
+    /**
+     * Number of header bits for structured mode
+     */
+    define('STRUCTURE_HEADER_BITS', 20);
+
+    /**
+     * Max number of symbols for structured mode
+     */
+    define('MAX_STRUCTURED_SYMBOLS', 16);
+
+    // -----------------------------------------------------
+    // Masks
+
+    /**
+     * Down point base value for case 1 mask pattern (concatenation of same color in a line or a column)
+     */
+    define('N1', 3);
+
+    /**
+     * Down point base value for case 2 mask pattern (module block of same color)
+     */
+    define('N2', 3);
+
+    /**
+     * Down point base value for case 3 mask pattern (1:1:3:1:1(dark:bright:dark:bright:dark)pattern in a line or a column)
+     */
+    define('N3', 40);
+
+    /**
+     * Down point base value for case 4 mask pattern (ration of dark modules in whole)
+     */
+    define('N4', 10);
+
+    // -----------------------------------------------------
+    // Optimization settings
+
+    /**
+     * if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
+     */
+    define('QR_FIND_BEST_MASK', true);
+
+    /**
+     * if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
+     */
+    define('QR_FIND_FROM_RANDOM', 2);
+
+    /**
+     * when QR_FIND_BEST_MASK === false
+     */
+    define('QR_DEFAULT_MASK', 2);
+
+    // -----------------------------------------------------
+} // end of definitions
+// #*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#
+
+
+// #####################################################
+
+/**
+ * @author Dinesh Rabara
+ * @version 1.0.009
+ */
+class QRcode {
+
+    /**
+     * Barcode array to be returned which is readable by Dinesh Rabara.
+     * @protected
+     */
+    protected $barcode_array = array();
+
+    /**
+     * QR code version. Size of QRcode is defined as version. Version is from 1 to 40. Version 1 is 21*21 matrix. And 4 modules increases whenever 1 version increases. So version 40 is 177*177 matrix.
+     * @protected
+     */
+    protected $version = 0;
+
+    /**
+     * Levels of error correction. See definitions for possible values.
+     * @protected
+     */
+    protected $level = QR_ECLEVEL_L;
+
+    /**
+     * Encoding mode.
+     * @protected
+     */
+    protected $hint = QR_MODE_8B;
+
+    /**
+     * Boolean flag, if true the input string will be converted to uppercase.
+     * @protected
+     */
+    protected $casesensitive = true;
+
+    /**
+     * Structured QR code (not supported yet).
+     * @protected
+     */
+    protected $structured = 0;
+
+    /**
+     * Mask data.
+     * @protected
+     */
+    protected $data;
+
+    // FrameFiller
+
+    /**
+     * Width.
+     * @protected
+     */
+    protected $width;
+
+    /**
+     * Frame.
+     * @protected
+     */
+    protected $frame;
+
+    /**
+     * X position of bit.
+     * @protected
+     */
+    protected $x;
+
+    /**
+     * Y position of bit.
+     * @protected
+     */
+    protected $y;
+
+    /**
+     * Direction.
+     * @protected
+     */
+    protected $dir;
+
+    /**
+     * Single bit value.
+     * @protected
+     */
+    protected $bit;
+
+    // ---- QRrawcode ----
+
+    /**
+     * Data code.
+     * @protected
+     */
+    protected $datacode = array();
+
+    /**
+     * Error correction code.
+     * @protected
+     */
+    protected $ecccode = array();
+
+    /**
+     * Blocks.
+     * @protected
+     */
+    protected $blocks;
+
+    /**
+     * Reed-Solomon blocks.
+     * @protected
+     */
+    protected $rsblocks = array(); //of RSblock
+
+    /**
+     * Counter.
+     * @protected
+     */
+    protected $count;
+
+    /**
+     * Data length.
+     * @protected
+     */
+    protected $dataLength;
+
+    /**
+     * Error correction length.
+     * @protected
+     */
+    protected $eccLength;
+
+    /**
+     * Value b1.
+     * @protected
+     */
+    protected $b1;
+
+    // ---- QRmask ----
+
+    /**
+     * Run length.
+     * @protected
+     */
+    protected $runLength = array();
+
+    // ---- QRsplit ----
+
+    /**
+     * Input data string.
+     * @protected
+     */
+    protected $dataStr = '';
+
+    /**
+     * Input items.
+     * @protected
+     */
+    protected $items;
+
+    // Reed-Solomon items
+
+    /**
+     * Reed-Solomon items.
+     * @protected
+     */
+    protected $rsitems = array();
+
+    /**
+     * Array of frames.
+     * @protected
+     */
+    protected $frames = array();
+
+    /**
+     * Alphabet-numeric convesion table.
+     * @protected
+     */
+    protected $anTable = array(
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
+        36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, //
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, //
+        -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, //
+        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, //
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1  //
+    );
+
+    /**
+     * Array Table of the capacity of symbols.
+     * See Table 1 (pp.13) and Table 12-16 (pp.30-36), JIS X0510:2004.
+     * @protected
+     */
+    protected $capacity = array(
+        array(0, 0, 0, array(0, 0, 0, 0)), //
+        array(21, 26, 0, array(7, 10, 13, 17)), //  1
+        array(25, 44, 7, array(10, 16, 22, 28)), //
+        array(29, 70, 7, array(15, 26, 36, 44)), //
+        array(33, 100, 7, array(20, 36, 52, 64)), //
+        array(37, 134, 7, array(26, 48, 72, 88)), //  5
+        array(41, 172, 7, array(36, 64, 96, 112)), //
+        array(45, 196, 0, array(40, 72, 108, 130)), //
+        array(49, 242, 0, array(48, 88, 132, 156)), //
+        array(53, 292, 0, array(60, 110, 160, 192)), //
+        array(57, 346, 0, array(72, 130, 192, 224)), // 10
+        array(61, 404, 0, array(80, 150, 224, 264)), //
+        array(65, 466, 0, array(96, 176, 260, 308)), //
+        array(69, 532, 0, array(104, 198, 288, 352)), //
+        array(73, 581, 3, array(120, 216, 320, 384)), //
+        array(77, 655, 3, array(132, 240, 360, 432)), // 15
+        array(81, 733, 3, array(144, 280, 408, 480)), //
+        array(85, 815, 3, array(168, 308, 448, 532)), //
+        array(89, 901, 3, array(180, 338, 504, 588)), //
+        array(93, 991, 3, array(196, 364, 546, 650)), //
+        array(97, 1085, 3, array(224, 416, 600, 700)), // 20
+        array(101, 1156, 4, array(224, 442, 644, 750)), //
+        array(105, 1258, 4, array(252, 476, 690, 816)), //
+        array(109, 1364, 4, array(270, 504, 750, 900)), //
+        array(113, 1474, 4, array(300, 560, 810, 960)), //
+        array(117, 1588, 4, array(312, 588, 870, 1050)), // 25
+        array(121, 1706, 4, array(336, 644, 952, 1110)), //
+        array(125, 1828, 4, array(360, 700, 1020, 1200)), //
+        array(129, 1921, 3, array(390, 728, 1050, 1260)), //
+        array(133, 2051, 3, array(420, 784, 1140, 1350)), //
+        array(137, 2185, 3, array(450, 812, 1200, 1440)), // 30
+        array(141, 2323, 3, array(480, 868, 1290, 1530)), //
+        array(145, 2465, 3, array(510, 924, 1350, 1620)), //
+        array(149, 2611, 3, array(540, 980, 1440, 1710)), //
+        array(153, 2761, 3, array(570, 1036, 1530, 1800)), //
+        array(157, 2876, 0, array(570, 1064, 1590, 1890)), // 35
+        array(161, 3034, 0, array(600, 1120, 1680, 1980)), //
+        array(165, 3196, 0, array(630, 1204, 1770, 2100)), //
+        array(169, 3362, 0, array(660, 1260, 1860, 2220)), //
+        array(173, 3532, 0, array(720, 1316, 1950, 2310)), //
+        array(177, 3706, 0, array(750, 1372, 2040, 2430))  // 40
+    );
+
+    /**
+     * Array Length indicator.
+     * @protected
+     */
+    protected $lengthTableBits = array(
+        array(10, 12, 14),
+        array(9, 11, 13),
+        array(8, 16, 16),
+        array(8, 10, 12)
+    );
+
+    /**
+     * Array Table of the error correction code (Reed-Solomon block).
+     * See Table 12-16 (pp.30-36), JIS X0510:2004.
+     * @protected
+     */
+    protected $eccTable = array(
+        array(array(0, 0), array(0, 0), array(0, 0), array(0, 0)), //
+        array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), //  1
+        array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), //
+        array(array(1, 0), array(1, 0), array(2, 0), array(2, 0)), //
+        array(array(1, 0), array(2, 0), array(2, 0), array(4, 0)), //
+        array(array(1, 0), array(2, 0), array(2, 2), array(2, 2)), //  5
+        array(array(2, 0), array(4, 0), array(4, 0), array(4, 0)), //
+        array(array(2, 0), array(4, 0), array(2, 4), array(4, 1)), //
+        array(array(2, 0), array(2, 2), array(4, 2), array(4, 2)), //
+        array(array(2, 0), array(3, 2), array(4, 4), array(4, 4)), //
+        array(array(2, 2), array(4, 1), array(6, 2), array(6, 2)), // 10
+        array(array(4, 0), array(1, 4), array(4, 4), array(3, 8)), //
+        array(array(2, 2), array(6, 2), array(4, 6), array(7, 4)), //
+        array(array(4, 0), array(8, 1), array(8, 4), array(12, 4)), //
+        array(array(3, 1), array(4, 5), array(11, 5), array(11, 5)), //
+        array(array(5, 1), array(5, 5), array(5, 7), array(11, 7)), // 15
+        array(array(5, 1), array(7, 3), array(15, 2), array(3, 13)), //
+        array(array(1, 5), array(10, 1), array(1, 15), array(2, 17)), //
+        array(array(5, 1), array(9, 4), array(17, 1), array(2, 19)), //
+        array(array(3, 4), array(3, 11), array(17, 4), array(9, 16)), //
+        array(array(3, 5), array(3, 13), array(15, 5), array(15, 10)), // 20
+        array(array(4, 4), array(17, 0), array(17, 6), array(19, 6)), //
+        array(array(2, 7), array(17, 0), array(7, 16), array(34, 0)), //
+        array(array(4, 5), array(4, 14), array(11, 14), array(16, 14)), //
+        array(array(6, 4), array(6, 14), array(11, 16), array(30, 2)), //
+        array(array(8, 4), array(8, 13), array(7, 22), array(22, 13)), // 25
+        array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)), //
+        array(array(8, 4), array(22, 3), array(8, 26), array(12, 28)), //
+        array(array(3, 10), array(3, 23), array(4, 31), array(11, 31)), //
+        array(array(7, 7), array(21, 7), array(1, 37), array(19, 26)), //
+        array(array(5, 10), array(19, 10), array(15, 25), array(23, 25)), // 30
+        array(array(13, 3), array(2, 29), array(42, 1), array(23, 28)), //
+        array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)), //
+        array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)), //
+        array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)), //
+        array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), // 35
+        array(array(6, 14), array(6, 34), array(46, 10), array(2, 64)), //
+        array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)), //
+        array(array(4, 18), array(13, 32), array(48, 14), array(42, 32)), //
+        array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)), //
+        array(array(19, 6), array(18, 31), array(34, 34), array(20, 61))  // 40
+    );
+
+    /**
+     * Array Positions of alignment patterns.
+     * This array includes only the second and the third position of the alignment patterns. Rest of them can be calculated from the distance between them.
+     * See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
+     * @protected
+     */
+    protected $alignmentPattern = array(
+        array(0, 0),
+        array(0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), //  1- 5
+        array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), //  6-10
+        array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), // 11-15
+        array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), // 16-20
+        array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), // 21-25
+        array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), // 26-30
+        array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), // 31-35
+        array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58)  // 35-40
+    );
+
+    /**
+     * Array Version information pattern (BCH coded).
+     * See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
+     * size: [QRSPEC_VERSION_MAX - 6]
+     * @protected
+     */
+    protected $versionPattern = array(
+        0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d, //
+        0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9, //
+        0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75, //
+        0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64, //
+        0x27541, 0x28c69
+    );
+
+    /**
+     * Array Format information
+     * @protected
+     */
+    protected $formatInfo = array(
+        array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976), //
+        array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0), //
+        array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed), //
+        array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)  //
+    );
+
+    // -------------------------------------------------
+    // -------------------------------------------------
+
+    /**
+     * This is the class constructor.
+     * Creates a QRcode object
+     * @param $code (string) code to represent using QRcode
+     * @param $eclevel (string) error level: <ul><li>L : About 7% or less errors can be corrected.</li><li>M : About 15% or less errors can be corrected.</li><li>Q : About 25% or less errors can be corrected.</li><li>H : About 30% or less errors can be corrected.</li></ul>
+     * @public
+     * @since 1.0.000
+     */
+    public function __construct($code, $eclevel = 'L') {
+        $barcode_array = array();
+        if ((is_null($code)) OR ($code == '\0') OR ($code == '')) {
+            return false;
+        }
+        // set error correction level
+        $this->level = array_search($eclevel, array('L', 'M', 'Q', 'H'));
+        if ($this->level === false) {
+            $this->level = QR_ECLEVEL_L;
+        }
+        if (($this->hint != QR_MODE_8B) AND ($this->hint != QR_MODE_KJ)) {
+            return false;
+        }
+        if (($this->version < 0) OR ($this->version > QRSPEC_VERSION_MAX)) {
+            return false;
+        }
+        $this->items = array();
+        $this->encodeString($code);
+        if (is_null($this->data)) {
+            return false;
+        }
+        $qrTab = $this->binarize($this->data);
+        $size = count($qrTab);
+        $barcode_array['num_rows'] = $size;
+        $barcode_array['num_cols'] = $size;
+        $barcode_array['bcode'] = array();
+        foreach ($qrTab as $line) {
+            $arrAdd = array();
+            foreach (str_split($line) as $char) {
+                $arrAdd[] = ($char == '1') ? 1 : 0;
+            }
+            $barcode_array['bcode'][] = $arrAdd;
+        }
+        $this->barcode_array = $barcode_array;
+    }
+
+    /**
+     * Returns a barcode array which is readable by Dinesh Rabara
+     * @return array barcode array readable by Dinesh Rabara;
+     * @public
+     */
+    public function getBarcodeArray() {
+        return $this->barcode_array;
+    }
+
+    /**
+     * Convert the frame in binary form
+     * @param $frame (array) array to binarize
+     * @return array frame in binary form
+     */
+    protected function binarize($frame) {
+        $len = count($frame);
+        // the frame is square (width = height)
+        foreach ($frame as &$frameLine) {
+            for ($i = 0; $i < $len; $i++) {
+                $frameLine[$i] = (ord($frameLine[$i]) & 1) ? '1' : '0';
+            }
+        }
+        return $frame;
+    }
+
+    /**
+     * Encode the input string to QR code
+     * @param $string (string) input string to encode
+     */
+    protected function encodeString($string) {
+        $this->dataStr = $string;
+        if (!$this->casesensitive) {
+            $this->toUpper();
+        }
+        $ret = $this->splitString();
+        if ($ret < 0) {
+            return NULL;
+        }
+        $this->encodeMask(-1);
+    }
+
+    /**
+     * Encode mask
+     * @param $mask (int) masking mode
+     */
+    protected function encodeMask($mask) {
+        $spec = array(0, 0, 0, 0, 0);
+        $this->datacode = $this->getByteStream($this->items);
+        if (is_null($this->datacode)) {
+            return NULL;
+        }
+        $spec = $this->getEccSpec($this->version, $this->level, $spec);
+        $this->b1 = $this->rsBlockNum1($spec);
+        $this->dataLength = $this->rsDataLength($spec);
+        $this->eccLength = $this->rsEccLength($spec);
+        $this->ecccode = array_fill(0, $this->eccLength, 0);
+        $this->blocks = $this->rsBlockNum($spec);
+        $ret = $this->init($spec);
+        if ($ret < 0) {
+            return NULL;
+        }
+        $this->count = 0;
+        $this->width = $this->getWidth($this->version);
+        $this->frame = $this->newFrame($this->version);
+        $this->x = $this->width - 1;
+        $this->y = $this->width - 1;
+        $this->dir = -1;
+        $this->bit = -1;
+        // inteleaved data and ecc codes
+        for ($i = 0; $i < ($this->dataLength + $this->eccLength); $i++) {
+            $code = $this->getCode();
+            $bit = 0x80;
+            for ($j = 0; $j < 8; $j++) {
+                $addr = $this->getNextPosition();
+                $this->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
+                $bit = $bit >> 1;
+            }
+        }
+        // remainder bits
+        $j = $this->getRemainder($this->version);
+        for ($i = 0; $i < $j; $i++) {
+            $addr = $this->getNextPosition();
+            $this->setFrameAt($addr, 0x02);
+        }
+        // masking
+        $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
+        if ($mask < 0) {
+            if (QR_FIND_BEST_MASK) {
+                $masked = $this->mask($this->width, $this->frame, $this->level);
+            } else {
+                $masked = $this->makeMask($this->width, $this->frame, (intval(QR_DEFAULT_MASK) % 8), $this->level);
+            }
+        } else {
+            $masked = $this->makeMask($this->width, $this->frame, $mask, $this->level);
+        }
+        if ($masked == NULL) {
+            return NULL;
+        }
+        $this->data = $masked;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // FrameFiller
+
+    /**
+     * Set frame value at specified position
+     * @param $at (array) x,y position
+     * @param $val (int) value of the character to set
+     */
+    protected function setFrameAt($at, $val) {
+        $this->frame[$at['y']][$at['x']] = chr($val);
+    }
+
+    /**
+     * Get frame value at specified position
+     * @param $at (array) x,y position
+     * @return value at specified position
+     */
+    protected function getFrameAt($at) {
+        return ord($this->frame[$at['y']][$at['x']]);
+    }
+
+    /**
+     * Return the next frame position
+     * @return array of x,y coordinates
+     */
+    protected function getNextPosition() {
+        do {
+            if ($this->bit == -1) {
+                $this->bit = 0;
+                return array('x' => $this->x, 'y' => $this->y);
+            }
+            $x = $this->x;
+            $y = $this->y;
+            $w = $this->width;
+            if ($this->bit == 0) {
+                $x--;
+                $this->bit++;
+            } else {
+                $x++;
+                $y += $this->dir;
+                $this->bit--;
+            }
+            if ($this->dir < 0) {
+                if ($y < 0) {
+                    $y = 0;
+                    $x -= 2;
+                    $this->dir = 1;
+                    if ($x == 6) {
+                        $x--;
+                        $y = 9;
+                    }
+                }
+            } else {
+                if ($y == $w) {
+                    $y = $w - 1;
+                    $x -= 2;
+                    $this->dir = -1;
+                    if ($x == 6) {
+                        $x--;
+                        $y -= 8;
+                    }
+                }
+            }
+            if (($x < 0) OR ($y < 0)) {
+                return NULL;
+            }
+            $this->x = $x;
+            $this->y = $y;
+        } while (ord($this->frame[$y][$x]) & 0x80);
+        return array('x' => $x, 'y' => $y);
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRrawcode
+
+    /**
+     * Initialize code.
+     * @param $spec (array) array of ECC specification
+     * @return 0 in case of success, -1 in case of error
+     */
+    protected function init($spec) {
+        $dl = $this->rsDataCodes1($spec);
+        $el = $this->rsEccCodes1($spec);
+        $rs = $this->init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+        $blockNo = 0;
+        $dataPos = 0;
+        $eccPos = 0;
+        $endfor = $this->rsBlockNum1($spec);
+        for ($i = 0; $i < $endfor; ++$i) {
+            $ecc = array_slice($this->ecccode, $eccPos);
+            $this->rsblocks[$blockNo] = array();
+            $this->rsblocks[$blockNo]['dataLength'] = $dl;
+            $this->rsblocks[$blockNo]['data'] = array_slice($this->datacode, $dataPos);
+            $this->rsblocks[$blockNo]['eccLength'] = $el;
+            $ecc = $this->encode_rs_char($rs, $this->rsblocks[$blockNo]['data'], $ecc);
+            $this->rsblocks[$blockNo]['ecc'] = $ecc;
+            $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
+            $dataPos += $dl;
+            $eccPos += $el;
+            $blockNo++;
+        }
+        if ($this->rsBlockNum2($spec) == 0) {
+            return 0;
+        }
+        $dl = $this->rsDataCodes2($spec);
+        $el = $this->rsEccCodes2($spec);
+        $rs = $this->init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+        if ($rs == NULL) {
+            return -1;
+        }
+        $endfor = $this->rsBlockNum2($spec);
+        for ($i = 0; $i < $endfor; ++$i) {
+            $ecc = array_slice($this->ecccode, $eccPos);
+            $this->rsblocks[$blockNo] = array();
+            $this->rsblocks[$blockNo]['dataLength'] = $dl;
+            $this->rsblocks[$blockNo]['data'] = array_slice($this->datacode, $dataPos);
+            $this->rsblocks[$blockNo]['eccLength'] = $el;
+            $ecc = $this->encode_rs_char($rs, $this->rsblocks[$blockNo]['data'], $ecc);
+            $this->rsblocks[$blockNo]['ecc'] = $ecc;
+            $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
+            $dataPos += $dl;
+            $eccPos += $el;
+            $blockNo++;
+        }
+        return 0;
+    }
+
+    /**
+     * Return Reed-Solomon block code.
+     * @return array rsblocks
+     */
+    protected function getCode() {
+        if ($this->count < $this->dataLength) {
+            $row = $this->count % $this->blocks;
+            $col = $this->count / $this->blocks;
+            if ($col >= $this->rsblocks[0]['dataLength']) {
+                $row += $this->b1;
+            }
+            $ret = $this->rsblocks[$row]['data'][$col];
+        } elseif ($this->count < $this->dataLength + $this->eccLength) {
+            $row = ($this->count - $this->dataLength) % $this->blocks;
+            $col = ($this->count - $this->dataLength) / $this->blocks;
+            $ret = $this->rsblocks[$row]['ecc'][$col];
+        } else {
+            return 0;
+        }
+        $this->count++;
+        return $ret;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRmask
+
+    /**
+     * Write Format Information on frame and returns the number of black bits
+     * @param $width (int) frame width
+     * @param $frame (array) frame
+     * @param $mask (array) masking mode
+     * @param $level (int) error correction level
+     * @return int blacks
+     */
+    protected function writeFormatInformation($width, &$frame, $mask, $level) {
+        $blacks = 0;
+        $format = $this->getFormatInfo($mask, $level);
+        for ($i = 0; $i < 8; ++$i) {
+            if ($format & 1) {
+                $blacks += 2;
+                $v = 0x85;
+            } else {
+                $v = 0x84;
+            }
+            $frame[8][$width - 1 - $i] = chr($v);
+            if ($i < 6) {
+                $frame[$i][8] = chr($v);
+            } else {
+                $frame[$i + 1][8] = chr($v);
+            }
+            $format = $format >> 1;
+        }
+        for ($i = 0; $i < 7; ++$i) {
+            if ($format & 1) {
+                $blacks += 2;
+                $v = 0x85;
+            } else {
+                $v = 0x84;
+            }
+            $frame[$width - 7 + $i][8] = chr($v);
+            if ($i == 0) {
+                $frame[8][7] = chr($v);
+            } else {
+                $frame[8][6 - $i] = chr($v);
+            }
+            $format = $format >> 1;
+        }
+        return $blacks;
+    }
+
+    /**
+     * mask0
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask0($x, $y) {
+        return ($x + $y) & 1;
+    }
+
+    /**
+     * mask1
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask1($x, $y) {
+        return ($y & 1);
+    }
+
+    /**
+     * mask2
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask2($x, $y) {
+        return ($x % 3);
+    }
+
+    /**
+     * mask3
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask3($x, $y) {
+        return ($x + $y) % 3;
+    }
+
+    /**
+     * mask4
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask4($x, $y) {
+        return (((int) ($y / 2)) + ((int) ($x / 3))) & 1;
+    }
+
+    /**
+     * mask5
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask5($x, $y) {
+        return (($x * $y) & 1) + ($x * $y) % 3;
+    }
+
+    /**
+     * mask6
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask6($x, $y) {
+        return ((($x * $y) & 1) + ($x * $y) % 3) & 1;
+    }
+
+    /**
+     * mask7
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @return int mask
+     */
+    protected function mask7($x, $y) {
+        return ((($x * $y) % 3) + (($x + $y) & 1)) & 1;
+    }
+
+    /**
+     * Return bitmask
+     * @param $maskNo (int) mask number
+     * @param $width (int) width
+     * @param $frame (array) frame
+     * @return array bitmask
+     */
+    protected function generateMaskNo($maskNo, $width, $frame) {
+        $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
+        for ($y = 0; $y < $width; ++$y) {
+            for ($x = 0; $x < $width; ++$x) {
+                if (ord($frame[$y][$x]) & 0x80) {
+                    $bitMask[$y][$x] = 0;
+                } else {
+                    $maskFunc = call_user_func(array($this, 'mask' . $maskNo), $x, $y);
+                    $bitMask[$y][$x] = ($maskFunc == 0) ? 1 : 0;
+                }
+            }
+        }
+        return $bitMask;
+    }
+
+    /**
+     * makeMaskNo
+     * @param $maskNo (int)
+     * @param $width (int)
+     * @param $s (int)
+     * @param $d (int)
+     * @param $maskGenOnly (boolean)
+     * @return int b
+     */
+    protected function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false) {
+        $b = 0;
+        $bitMask = array();
+        $bitMask = $this->generateMaskNo($maskNo, $width, $s, $d);
+        if ($maskGenOnly) {
+            return;
+        }
+        $d = $s;
+        for ($y = 0; $y < $width; ++$y) {
+            for ($x = 0; $x < $width; ++$x) {
+                if ($bitMask[$y][$x] == 1) {
+                    $d[$y][$x] = chr(ord($s[$y][$x]) ^ ((int) ($bitMask[$y][$x])));
+                }
+                $b += (int) (ord($d[$y][$x]) & 1);
+            }
+        }
+        return $b;
+    }
+
+    /**
+     * makeMask
+     * @param $width (int)
+     * @param $frame (array)
+     * @param $maskNo (int)
+     * @param $level (int)
+     * @return array mask
+     */
+    protected function makeMask($width, $frame, $maskNo, $level) {
+        $masked = array_fill(0, $width, str_repeat("\0", $width));
+        $this->makeMaskNo($maskNo, $width, $frame, $masked);
+        $this->writeFormatInformation($width, $masked, $maskNo, $level);
+        return $masked;
+    }
+
+    /**
+     * calcN1N3
+     * @param $length (int)
+     * @return int demerit
+     */
+    protected function calcN1N3($length) {
+        $demerit = 0;
+        for ($i = 0; $i < $length; ++$i) {
+            if ($this->runLength[$i] >= 5) {
+                $demerit += (N1 + ($this->runLength[$i] - 5));
+            }
+            if ($i & 1) {
+                if (($i >= 3) AND ($i < ($length - 2)) AND ($this->runLength[$i] % 3 == 0)) {
+                    $fact = (int) ($this->runLength[$i] / 3);
+                    if (($this->runLength[$i - 2] == $fact)
+                            AND ($this->runLength[$i - 1] == $fact)
+                            AND ($this->runLength[$i + 1] == $fact)
+                            AND ($this->runLength[$i + 2] == $fact)) {
+                        if (($this->runLength[$i - 3] < 0) OR ($this->runLength[$i - 3] >= (4 * $fact))) {
+                            $demerit += N3;
+                        } elseif ((($i + 3) >= $length) OR ($this->runLength[$i + 3] >= (4 * $fact))) {
+                            $demerit += N3;
+                        }
+                    }
+                }
+            }
+        }
+        return $demerit;
+    }
+
+    /**
+     * evaluateSymbol
+     * @param $width (int)
+     * @param $frame (array)
+     * @return int demerit
+     */
+    protected function evaluateSymbol($width, $frame) {
+        $head = 0;
+        $demerit = 0;
+        for ($y = 0; $y < $width; ++$y) {
+            $head = 0;
+            $this->runLength[0] = 1;
+            $frameY = $frame[$y];
+            if ($y > 0) {
+                $frameYM = $frame[$y - 1];
+            }
+            for ($x = 0; $x < $width; ++$x) {
+                if (($x > 0) AND ($y > 0)) {
+                    $b22 = ord($frameY[$x]) & ord($frameY[$x - 1]) & ord($frameYM[$x]) & ord($frameYM[$x - 1]);
+                    $w22 = ord($frameY[$x]) | ord($frameY[$x - 1]) | ord($frameYM[$x]) | ord($frameYM[$x - 1]);
+                    if (($b22 | ($w22 ^ 1)) & 1) {
+                        $demerit += N2;
+                    }
+                }
+                if (($x == 0) AND (ord($frameY[$x]) & 1)) {
+                    $this->runLength[0] = -1;
+                    $head = 1;
+                    $this->runLength[$head] = 1;
+                } elseif ($x > 0) {
+                    if ((ord($frameY[$x]) ^ ord($frameY[$x - 1])) & 1) {
+                        $head++;
+                        $this->runLength[$head] = 1;
+                    } else {
+                        $this->runLength[$head]++;
+                    }
+                }
+            }
+            $demerit += $this->calcN1N3($head + 1);
+        }
+        for ($x = 0; $x < $width; ++$x) {
+            $head = 0;
+            $this->runLength[0] = 1;
+            for ($y = 0; $y < $width; ++$y) {
+                if (($y == 0) AND (ord($frame[$y][$x]) & 1)) {
+                    $this->runLength[0] = -1;
+                    $head = 1;
+                    $this->runLength[$head] = 1;
+                } elseif ($y > 0) {
+                    if ((ord($frame[$y][$x]) ^ ord($frame[$y - 1][$x])) & 1) {
+                        $head++;
+                        $this->runLength[$head] = 1;
+                    } else {
+                        $this->runLength[$head]++;
+                    }
+                }
+            }
+            $demerit += $this->calcN1N3($head + 1);
+        }
+        return $demerit;
+    }
+
+    /**
+     * mask
+     * @param $width (int)
+     * @param $frame (array)
+     * @param $level (int)
+     * @return array best mask
+     */
+    protected function mask($width, $frame, $level) {
+        $minDemerit = PHP_INT_MAX;
+        $bestMaskNum = 0;
+        $bestMask = array();
+        $checked_masks = array(0, 1, 2, 3, 4, 5, 6, 7);
+        if (QR_FIND_FROM_RANDOM !== false) {
+            $howManuOut = 8 - (QR_FIND_FROM_RANDOM % 9);
+            for ($i = 0; $i < $howManuOut; ++$i) {
+                $remPos = rand(0, count($checked_masks) - 1);
+                unset($checked_masks[$remPos]);
+                $checked_masks = array_values($checked_masks);
+            }
+        }
+        $bestMask = $frame;
+        foreach ($checked_masks as $i) {
+            $mask = array_fill(0, $width, str_repeat("\0", $width));
+            $demerit = 0;
+            $blacks = 0;
+            $blacks = $this->makeMaskNo($i, $width, $frame, $mask);
+            $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
+            $blacks = (int) (100 * $blacks / ($width * $width));
+            $demerit = (int) ((int) (abs($blacks - 50) / 5) * N4);
+            $demerit += $this->evaluateSymbol($width, $mask);
+            if ($demerit < $minDemerit) {
+                $minDemerit = $demerit;
+                $bestMask = $mask;
+                $bestMaskNum = $i;
+            }
+        }
+        return $bestMask;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRsplit
+
+    /**
+     * Return true if the character at specified position is a number
+     * @param $str (string) string
+     * @param $pos (int) characted position
+     * @return boolean true of false
+     */
+    protected function isdigitat($str, $pos) {
+        if ($pos >= strlen($str)) {
+            return false;
+        }
+        return ((ord($str[$pos]) >= ord('0')) && (ord($str[$pos]) <= ord('9')));
+    }
+
+    /**
+     * Return true if the character at specified position is an alphanumeric character
+     * @param $str (string) string
+     * @param $pos (int) characted position
+     * @return boolean true of false
+     */
+    protected function isalnumat($str, $pos) {
+        if ($pos >= strlen($str)) {
+            return false;
+        }
+        return ($this->lookAnTable(ord($str[$pos])) >= 0);
+    }
+
+    /**
+     * identifyMode
+     * @param $pos (int)
+     * @return int mode
+     */
+    protected function identifyMode($pos) {
+        if ($pos >= strlen($this->dataStr)) {
+            return QR_MODE_NL;
+        }
+        $c = $this->dataStr[$pos];
+        if ($this->isdigitat($this->dataStr, $pos)) {
+            return QR_MODE_NM;
+        } elseif ($this->isalnumat($this->dataStr, $pos)) {
+            return QR_MODE_AN;
+        } elseif ($this->hint == QR_MODE_KJ) {
+            if ($pos + 1 < strlen($this->dataStr)) {
+                $d = $this->dataStr[$pos + 1];
+                $word = (ord($c) << 8) | ord($d);
+                if (($word >= 0x8140 && $word <= 0x9ffc) OR ($word >= 0xe040 && $word <= 0xebbf)) {
+                    return QR_MODE_KJ;
+                }
+            }
+        }
+        return QR_MODE_8B;
+    }
+
+    /**
+     * eatNum
+     * @return int run
+     */
+    protected function eatNum() {
+        $ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
+        $p = 0;
+        while ($this->isdigitat($this->dataStr, $p)) {
+            $p++;
+        }
+        $run = $p;
+        $mode = $this->identifyMode($p);
+        if ($mode == QR_MODE_8B) {
+            $dif = $this->estimateBitsModeNum($run) + 4 + $ln
+                    + $this->estimateBitsMode8(1)         // + 4 + l8
+                    - $this->estimateBitsMode8($run + 1); // - 4 - l8
+            if ($dif > 0) {
+                return $this->eat8();
+            }
+        }
+        if ($mode == QR_MODE_AN) {
+            $dif = $this->estimateBitsModeNum($run) + 4 + $ln
+                    + $this->estimateBitsModeAn(1)        // + 4 + la
+                    - $this->estimateBitsModeAn($run + 1); // - 4 - la
+            if ($dif > 0) {
+                return $this->eatAn();
+            }
+        }
+        $this->items = $this->appendNewInputItem($this->items, QR_MODE_NM, $run, str_split($this->dataStr));
+        return $run;
+    }
+
+    /**
+     * eatAn
+     * @return int run
+     */
+    protected function eatAn() {
+        $la = $this->lengthIndicator(QR_MODE_AN, $this->version);
+        $ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
+        $p = 1;
+        while ($this->isalnumat($this->dataStr, $p)) {
+            if ($this->isdigitat($this->dataStr, $p)) {
+                $q = $p;
+                while ($this->isdigitat($this->dataStr, $q)) {
+                    $q++;
+                }
+                $dif = $this->estimateBitsModeAn($p) // + 4 + la
+                        + $this->estimateBitsModeNum($q - $p) + 4 + $ln
+                        - $this->estimateBitsModeAn($q); // - 4 - la
+                if ($dif < 0) {
+                    break;
+                } else {
+                    $p = $q;
+                }
+            } else {
+                $p++;
+            }
+        }
+        $run = $p;
+        if (!$this->isalnumat($this->dataStr, $p)) {
+            $dif = $this->estimateBitsModeAn($run) + 4 + $la
+                    + $this->estimateBitsMode8(1) // + 4 + l8
+                    - $this->estimateBitsMode8($run + 1); // - 4 - l8
+            if ($dif > 0) {
+                return $this->eat8();
+            }
+        }
+        $this->items = $this->appendNewInputItem($this->items, QR_MODE_AN, $run, str_split($this->dataStr));
+        return $run;
+    }
+
+    /**
+     * eatKanji
+     * @return int run
+     */
+    protected function eatKanji() {
+        $p = 0;
+        while ($this->identifyMode($p) == QR_MODE_KJ) {
+            $p += 2;
+        }
+        $this->items = $this->appendNewInputItem($this->items, QR_MODE_KJ, $p, str_split($this->dataStr));
+        return $run;
+    }
+
+    /**
+     * eat8
+     * @return int run
+     */
+    protected function eat8() {
+        $la = $this->lengthIndicator(QR_MODE_AN, $this->version);
+        $ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
+        $p = 1;
+        $dataStrLen = strlen($this->dataStr);
+        while ($p < $dataStrLen) {
+            $mode = $this->identifyMode($p);
+            if ($mode == QR_MODE_KJ) {
+                break;
+            }
+            if ($mode == QR_MODE_NM) {
+                $q = $p;
+                while ($this->isdigitat($this->dataStr, $q)) {
+                    $q++;
+                }
+                $dif = $this->estimateBitsMode8($p) // + 4 + l8
+                        + $this->estimateBitsModeNum($q - $p) + 4 + $ln
+                        - $this->estimateBitsMode8($q); // - 4 - l8
+                if ($dif < 0) {
+                    break;
+                } else {
+                    $p = $q;
+                }
+            } elseif ($mode == QR_MODE_AN) {
+                $q = $p;
+                while ($this->isalnumat($this->dataStr, $q)) {
+                    $q++;
+                }
+                $dif = $this->estimateBitsMode8($p)  // + 4 + l8
+                        + $this->estimateBitsModeAn($q - $p) + 4 + $la
+                        - $this->estimateBitsMode8($q); // - 4 - l8
+                if ($dif < 0) {
+                    break;
+                } else {
+                    $p = $q;
+                }
+            } else {
+                $p++;
+            }
+        }
+        $run = $p;
+        $this->items = $this->appendNewInputItem($this->items, QR_MODE_8B, $run, str_split($this->dataStr));
+        return $run;
+    }
+
+    /**
+     * splitString
+     */
+    protected function splitString() {
+        while (strlen($this->dataStr) > 0) {
+            if ($this->dataStr == '') {
+                return 0;
+            }
+            $mode = $this->identifyMode(0);
+            switch ($mode) {
+                case QR_MODE_NM: {
+                        $length = $this->eatNum();
+                        break;
+                    }
+                case QR_MODE_AN: {
+                        $length = $this->eatAn();
+                        break;
+                    }
+                case QR_MODE_KJ: {
+                        if ($hint == QR_MODE_KJ) {
+                            $length = $this->eatKanji();
+                        } else {
+                            $length = $this->eat8();
+                        }
+                        break;
+                    }
+                default: {
+                        $length = $this->eat8();
+                        break;
+                    }
+            }
+            if ($length == 0) {
+                return 0;
+            }
+            if ($length < 0) {
+                return -1;
+            }
+            $this->dataStr = substr($this->dataStr, $length);
+        }
+    }
+
+    /**
+     * toUpper
+     */
+    protected function toUpper() {
+        $stringLen = strlen($this->dataStr);
+        $p = 0;
+        while ($p < $stringLen) {
+            $mode = $this->identifyMode(substr($this->dataStr, $p), $this->hint);
+            if ($mode == QR_MODE_KJ) {
+                $p += 2;
+            } else {
+                if ((ord($this->dataStr[$p]) >= ord('a')) AND (ord($this->dataStr[$p]) <= ord('z'))) {
+                    $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
+                }
+                $p++;
+            }
+        }
+        return $this->dataStr;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRinputItem
+
+    /**
+     * newInputItem
+     * @param $mode (int)
+     * @param $size (int)
+     * @param $data (array)
+     * @param $bstream (array)
+     * @return array input item
+     */
+    protected function newInputItem($mode, $size, $data, $bstream = null) {
+        $setData = array_slice($data, 0, $size);
+        if (count($setData) < $size) {
+            $setData = array_merge($setData, array_fill(0, ($size - count($setData)), 0));
+        }
+        if (!$this->check($mode, $size, $setData)) {
+            return NULL;
+        }
+        $inputitem = array();
+        $inputitem['mode'] = $mode;
+        $inputitem['size'] = $size;
+        $inputitem['data'] = $setData;
+        $inputitem['bstream'] = $bstream;
+        return $inputitem;
+    }
+
+    /**
+     * encodeModeNum
+     * @param $inputitem (array)
+     * @param $version (int)
+     * @return array input item
+     */
+    protected function encodeModeNum($inputitem, $version) {
+        $words = (int) ($inputitem['size'] / 3);
+        $inputitem['bstream'] = array();
+        $val = 0x1;
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, $val);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_NM, $version), $inputitem['size']);
+        for ($i = 0; $i < $words; ++$i) {
+            $val = (ord($inputitem['data'][$i * 3]) - ord('0')) * 100;
+            $val += (ord($inputitem['data'][$i * 3 + 1]) - ord('0')) * 10;
+            $val += (ord($inputitem['data'][$i * 3 + 2]) - ord('0'));
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 10, $val);
+        }
+        if ($inputitem['size'] - $words * 3 == 1) {
+            $val = ord($inputitem['data'][$words * 3]) - ord('0');
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, $val);
+        } elseif (($inputitem['size'] - ($words * 3)) == 2) {
+            $val = (ord($inputitem['data'][$words * 3]) - ord('0')) * 10;
+            $val += (ord($inputitem['data'][$words * 3 + 1]) - ord('0'));
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 7, $val);
+        }
+        return $inputitem;
+    }
+
+    /**
+     * encodeModeAn
+     * @param $inputitem (array)
+     * @param $version (int)
+     * @return array input item
+     */
+    protected function encodeModeAn($inputitem, $version) {
+        $words = (int) ($inputitem['size'] / 2);
+        $inputitem['bstream'] = array();
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x02);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_AN, $version), $inputitem['size']);
+        for ($i = 0; $i < $words; ++$i) {
+            $val = (int) ($this->lookAnTable(ord($inputitem['data'][$i * 2])) * 45);
+            $val += (int) ($this->lookAnTable(ord($inputitem['data'][($i * 2) + 1])));
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 11, $val);
+        }
+        if ($inputitem['size'] & 1) {
+            $val = $this->lookAnTable(ord($inputitem['data'][($words * 2)]));
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 6, $val);
+        }
+        return $inputitem;
+    }
+
+    /**
+     * encodeMode8
+     * @param $inputitem (array)
+     * @param $version (int)
+     * @return array input item
+     */
+    protected function encodeMode8($inputitem, $version) {
+        $inputitem['bstream'] = array();
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x4);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_8B, $version), $inputitem['size']);
+        for ($i = 0; $i < $inputitem['size']; ++$i) {
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 8, ord($inputitem['data'][$i]));
+        }
+        return $inputitem;
+    }
+
+    /**
+     * encodeModeKanji
+     * @param $inputitem (array)
+     * @param $version (int)
+     * @return array input item
+     */
+    protected function encodeModeKanji($inputitem, $version) {
+        $inputitem['bstream'] = array();
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x8);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_KJ, $version), (int) ($inputitem['size'] / 2));
+        for ($i = 0; $i < $inputitem['size']; $i+=2) {
+            $val = (ord($inputitem['data'][$i]) << 8) | ord($inputitem['data'][$i + 1]);
+            if ($val <= 0x9ffc) {
+                $val -= 0x8140;
+            } else {
+                $val -= 0xc140;
+            }
+            $h = ($val >> 8) * 0xc0;
+            $val = ($val & 0xff) + $h;
+            $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 13, $val);
+        }
+        return $inputitem;
+    }
+
+    /**
+     * encodeModeStructure
+     * @param $inputitem (array)
+     * @return array input item
+     */
+    protected function encodeModeStructure($inputitem) {
+        $inputitem['bstream'] = array();
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x03);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, ord($inputitem['data'][1]) - 1);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, ord($inputitem['data'][0]) - 1);
+        $inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 8, ord($inputitem['data'][2]));
+        return $inputitem;
+    }
+
+    /**
+     * encodeBitStream
+     * @param $inputitem (array)
+     * @param $version (int)
+     * @return array input item
+     */
+    protected function encodeBitStream($inputitem, $version) {
+        $inputitem['bstream'] = array();
+        $words = $this->maximumWords($inputitem['mode'], $version);
+        if ($inputitem['size'] > $words) {
+            $st1 = $this->newInputItem($inputitem['mode'], $words, $inputitem['data']);
+            $st2 = $this->newInputItem($inputitem['mode'], $inputitem['size'] - $words, array_slice($inputitem['data'], $words));
+            $st1 = $this->encodeBitStream($st1, $version);
+            $st2 = $this->encodeBitStream($st2, $version);
+            $inputitem['bstream'] = array();
+            $inputitem['bstream'] = $this->appendBitstream($inputitem['bstream'], $st1['bstream']);
+            $inputitem['bstream'] = $this->appendBitstream($inputitem['bstream'], $st2['bstream']);
+        } else {
+            switch ($inputitem['mode']) {
+                case QR_MODE_NM: {
+                        $inputitem = $this->encodeModeNum($inputitem, $version);
+                        break;
+                    }
+                case QR_MODE_AN: {
+                        $inputitem = $this->encodeModeAn($inputitem, $version);
+                        break;
+                    }
+                case QR_MODE_8B: {
+                        $inputitem = $this->encodeMode8($inputitem, $version);
+                        break;
+                    }
+                case QR_MODE_KJ: {
+                        $inputitem = $this->encodeModeKanji($inputitem, $version);
+                        break;
+                    }
+                case QR_MODE_ST: {
+                        $inputitem = $this->encodeModeStructure($inputitem);
+                        break;
+                    }
+                default: {
+                        break;
+                    }
+            }
+        }
+        return $inputitem;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRinput
+
+    /**
+     * Append data to an input object.
+     * The data is copied and appended to the input object.
+     * @param $items (arrray) input items
+     * @param $mode (int) encoding mode.
+     * @param $size (int) size of data (byte).
+     * @param $data (array) array of input data.
+     * @return items
+     *
+     */
+    protected function appendNewInputItem($items, $mode, $size, $data) {
+        $newitem = $this->newInputItem($mode, $size, $data);
+        if (!empty($newitem)) {
+            $items[] = $newitem;
+        }
+        return $items;
+    }
+
+    /**
+     * insertStructuredAppendHeader
+     * @param $items (array)
+     * @param $size (int)
+     * @param $index (int)
+     * @param $parity (int)
+     * @return array items
+     */
+    protected function insertStructuredAppendHeader($items, $size, $index, $parity) {
+        if ($size > MAX_STRUCTURED_SYMBOLS) {
+            return -1;
+        }
+        if (($index <= 0) OR ($index > MAX_STRUCTURED_SYMBOLS)) {
+            return -1;
+        }
+        $buf = array($size, $index, $parity);
+        $entry = $this->newInputItem(QR_MODE_ST, 3, buf);
+        array_unshift($items, $entry);
+        return $items;
+    }
+
+    /**
+     * calcParity
+     * @param $items (array)
+     * @return int parity
+     */
+    protected function calcParity($items) {
+        $parity = 0;
+        foreach ($items as $item) {
+            if ($item['mode'] != QR_MODE_ST) {
+                for ($i = $item['size'] - 1; $i >= 0; --$i) {
+                    $parity ^= $item['data'][$i];
+                }
+            }
+        }
+        return $parity;
+    }
+
+    /**
+     * checkModeNum
+     * @param $size (int)
+     * @param $data (array)
+     * @return boolean true or false
+     */
+    protected function checkModeNum($size, $data) {
+        for ($i = 0; $i < $size; ++$i) {
+            if ((ord($data[$i]) < ord('0')) OR (ord($data[$i]) > ord('9'))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Look up the alphabet-numeric convesion table (see JIS X0510:2004, pp.19).
+     * @param $c (int) character value
+     * @return value
+     */
+    protected function lookAnTable($c) {
+        return (($c > 127) ? -1 : $this->anTable[$c]);
+    }
+
+    /**
+     * checkModeAn
+     * @param $size (int)
+     * @param $data (array)
+     * @return boolean true or false
+     */
+    protected function checkModeAn($size, $data) {
+        for ($i = 0; $i < $size; ++$i) {
+            if ($this->lookAnTable(ord($data[$i])) == -1) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * estimateBitsModeNum
+     * @param $size (int)
+     * @return int number of bits
+     */
+    protected function estimateBitsModeNum($size) {
+        $w = (int) ($size / 3);
+        $bits = ($w * 10);
+        switch ($size - ($w * 3)) {
+            case 1: {
+                    $bits += 4;
+                    break;
+                }
+            case 2: {
+                    $bits += 7;
+                    break;
+                }
+        }
+        return $bits;
+    }
+
+    /**
+     * estimateBitsModeAn
+     * @param $size (int)
+     * @return int number of bits
+     */
+    protected function estimateBitsModeAn($size) {
+        $bits = (int) ($size * 5.5); // (size / 2 ) * 11
+        if ($size & 1) {
+            $bits += 6;
+        }
+        return $bits;
+    }
+
+    /**
+     * estimateBitsMode8
+     * @param $size (int)
+     * @return int number of bits
+     */
+    protected function estimateBitsMode8($size) {
+        return (int) ($size * 8);
+    }
+
+    /**
+     * estimateBitsModeKanji
+     * @param $size (int)
+     * @return int number of bits
+     */
+    protected function estimateBitsModeKanji($size) {
+        return (int) ($size * 6.5); // (size / 2 ) * 13
+    }
+
+    /**
+     * checkModeKanji
+     * @param $size (int)
+     * @param $data (array)
+     * @return boolean true or false
+     */
+    protected function checkModeKanji($size, $data) {
+        if ($size & 1) {
+            return false;
+        }
+        for ($i = 0; $i < $size; $i+=2) {
+            $val = (ord($data[$i]) << 8) | ord($data[$i + 1]);
+            if (($val < 0x8140) OR (($val > 0x9ffc) AND ($val < 0xe040)) OR ($val > 0xebbf)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Validate the input data.
+     * @param $mode (int) encoding mode.
+     * @param $size (int) size of data (byte).
+     * @param $data (array) data to validate
+     * @return boolean true in case of valid data, false otherwise
+     */
+    protected function check($mode, $size, $data) {
+        if ($size <= 0) {
+            return false;
+        }
+        switch ($mode) {
+            case QR_MODE_NM: {
+                    return $this->checkModeNum($size, $data);
+                }
+            case QR_MODE_AN: {
+                    return $this->checkModeAn($size, $data);
+                }
+            case QR_MODE_KJ: {
+                    return $this->checkModeKanji($size, $data);
+                }
+            case QR_MODE_8B: {
+                    return true;
+                }
+            case QR_MODE_ST: {
+                    return true;
+                }
+            default: {
+                    break;
+                }
+        }
+        return false;
+    }
+
+    /**
+     * estimateBitStreamSize
+     * @param $items (array)
+     * @param $version (int)
+     * @return int bits
+     */
+    protected function estimateBitStreamSize($items, $version) {
+        $bits = 0;
+        if ($version == 0) {
+            $version = 1;
+        }
+        foreach ($items as $item) {
+            switch ($item['mode']) {
+                case QR_MODE_NM: {
+                        $bits = $this->estimateBitsModeNum($item['size']);
+                        break;
+                    }
+                case QR_MODE_AN: {
+                        $bits = $this->estimateBitsModeAn($item['size']);
+                        break;
+                    }
+                case QR_MODE_8B: {
+                        $bits = $this->estimateBitsMode8($item['size']);
+                        break;
+                    }
+                case QR_MODE_KJ: {
+                        $bits = $this->estimateBitsModeKanji($item['size']);
+                        break;
+                    }
+                case QR_MODE_ST: {
+                        return STRUCTURE_HEADER_BITS;
+                    }
+                default: {
+                        return 0;
+                    }
+            }
+            $l = $this->lengthIndicator($item['mode'], $version);
+            $m = 1 << $l;
+            $num = (int) (($item['size'] + $m - 1) / $m);
+            $bits += $num * (4 + $l);
+        }
+        return $bits;
+    }
+
+    /**
+     * estimateVersion
+     * @param $items (array)
+     * @return int version
+     */
+    protected function estimateVersion($items) {
+        $version = 0;
+        $prev = 0;
+        do {
+            $prev = $version;
+            $bits = $this->estimateBitStreamSize($items, $prev);
+            $version = $this->getMinimumVersion((int) (($bits + 7) / 8), $this->level);
+            if ($version < 0) {
+                return -1;
+            }
+        } while ($version > $prev);
+        return $version;
+    }
+
+    /**
+     * lengthOfCode
+     * @param $mode (int)
+     * @param $version (int)
+     * @param $bits (int)
+     * @return int size
+     */
+    protected function lengthOfCode($mode, $version, $bits) {
+        $payload = $bits - 4 - $this->lengthIndicator($mode, $version);
+        switch ($mode) {
+            case QR_MODE_NM: {
+                    $chunks = (int) ($payload / 10);
+                    $remain = $payload - $chunks * 10;
+                    $size = $chunks * 3;
+                    if ($remain >= 7) {
+                        $size += 2;
+                    } elseif ($remain >= 4) {
+                        $size += 1;
+                    }
+                    break;
+                }
+            case QR_MODE_AN: {
+                    $chunks = (int) ($payload / 11);
+                    $remain = $payload - $chunks * 11;
+                    $size = $chunks * 2;
+                    if ($remain >= 6) {
+                        ++$size;
+                    }
+                    break;
+                }
+            case QR_MODE_8B: {
+                    $size = (int) ($payload / 8);
+                    break;
+                }
+            case QR_MODE_KJ: {
+                    $size = (int) (($payload / 13) * 2);
+                    break;
+                }
+            case QR_MODE_ST: {
+                    $size = (int) ($payload / 8);
+                    break;
+                }
+            default: {
+                    $size = 0;
+                    break;
+                }
+        }
+        $maxsize = $this->maximumWords($mode, $version);
+        if ($size < 0) {
+            $size = 0;
+        }
+        if ($size > $maxsize) {
+            $size = $maxsize;
+        }
+        return $size;
+    }
+
+    /**
+     * createBitStream
+     * @param $items (array)
+     * @return array of items and total bits
+     */
+    protected function createBitStream($items) {
+        $total = 0;
+        foreach ($items as $key => $item) {
+            $items[$key] = $this->encodeBitStream($item, $this->version);
+            $bits = count($items[$key]['bstream']);
+            $total += $bits;
+        }
+        return array($items, $total);
+    }
+
+    /**
+     * convertData
+     * @param $items (array)
+     * @return array items
+     */
+    protected function convertData($items) {
+        $ver = $this->estimateVersion($items);
+        if ($ver > $this->version) {
+            $this->version = $ver;
+        }
+        for (;;) {
+            $cbs = $this->createBitStream($items);
+            $items = $cbs[0];
+            $bits = $cbs[1];
+            if ($bits < 0) {
+                return -1;
+            }
+            $ver = $this->getMinimumVersion((int) (($bits + 7) / 8), $this->level);
+            if ($ver < 0) {
+                return -1;
+            } elseif ($ver > $this->version) {
+                $this->version = $ver;
+            } else {
+                break;
+            }
+        }
+        return $items;
+    }
+
+    /**
+     * Append Padding Bit to bitstream
+     * @param $bstream (array)
+     * @return array bitstream
+     */
+    protected function appendPaddingBit($bstream) {
+        if (is_null($bstream)) {
+            return null;
+        }
+        $bits = count($bstream);
+        $maxwords = $this->getDataLength($this->version, $this->level);
+        $maxbits = $maxwords * 8;
+        if ($maxbits == $bits) {
+            return $bstream;
+        }
+        if ($maxbits - $bits < 5) {
+            return $this->appendNum($bstream, $maxbits - $bits, 0);
+        }
+        $bits += 4;
+        $words = (int) (($bits + 7) / 8);
+        $padding = array();
+        $padding = $this->appendNum($padding, $words * 8 - $bits + 4, 0);
+        $padlen = $maxwords - $words;
+        if ($padlen > 0) {
+            $padbuf = array();
+            for ($i = 0; $i < $padlen; ++$i) {
+                $padbuf[$i] = ($i & 1) ? 0x11 : 0xec;
+            }
+            $padding = $this->appendBytes($padding, $padlen, $padbuf);
+        }
+        return $this->appendBitstream($bstream, $padding);
+    }
+
+    /**
+     * mergeBitStream
+     * @param $items (array) items
+     * @return array bitstream
+     */
+    protected function mergeBitStream($items) {
+        $items = $this->convertData($items);
+        if (!is_array($items)) {
+            return null;
+        }
+        $bstream = array();
+        foreach ($items as $item) {
+            $bstream = $this->appendBitstream($bstream, $item['bstream']);
+        }
+        return $bstream;
+    }
+
+    /**
+     * Returns a stream of bits.
+     * @param $items (int)
+     * @return array padded merged byte stream
+     */
+    protected function getBitStream($items) {
+        $bstream = $this->mergeBitStream($items);
+        return $this->appendPaddingBit($bstream);
+    }
+
+    /**
+     * Pack all bit streams padding bits into a byte array.
+     * @param $items (int)
+     * @return array padded merged byte stream
+     */
+    protected function getByteStream($items) {
+        $bstream = $this->getBitStream($items);
+        return $this->bitstreamToByte($bstream);
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRbitstream
+
+    /**
+     * Return an array with zeros
+     * @param $setLength (int) array size
+     * @return array
+     */
+    protected function allocate($setLength) {
+        return array_fill(0, $setLength, 0);
+    }
+
+    /**
+     * Return new bitstream from number
+     * @param $bits (int) number of bits
+     * @param $num (int) number
+     * @return array bitstream
+     */
+    protected function newFromNum($bits, $num) {
+        $bstream = $this->allocate($bits);
+        $mask = 1 << ($bits - 1);
+        for ($i = 0; $i < $bits; ++$i) {
+            if ($num & $mask) {
+                $bstream[$i] = 1;
+            } else {
+                $bstream[$i] = 0;
+            }
+            $mask = $mask >> 1;
+        }
+        return $bstream;
+    }
+
+    /**
+     * Return new bitstream from bytes
+     * @param $size (int) size
+     * @param $data (array) bytes
+     * @return array bitstream
+     */
+    protected function newFromBytes($size, $data) {
+        $bstream = $this->allocate($size * 8);
+        $p = 0;
+        for ($i = 0; $i < $size; ++$i) {
+            $mask = 0x80;
+            for ($j = 0; $j < 8; ++$j) {
+                if ($data[$i] & $mask) {
+                    $bstream[$p] = 1;
+                } else {
+                    $bstream[$p] = 0;
+                }
+                $p++;
+                $mask = $mask >> 1;
+            }
+        }
+        return $bstream;
+    }
+
+    /**
+     * Append one bitstream to another
+     * @param $bitstream (array) original bitstream
+     * @param $append (array) bitstream to append
+     * @return array bitstream
+     */
+    protected function appendBitstream($bitstream, $append) {
+        if ((!is_array($append)) OR (count($append) == 0)) {
+            return $bitstream;
+        }
+        if (count($bitstream) == 0) {
+            return $append;
+        }
+        return array_values(array_merge($bitstream, $append));
+    }
+
+    /**
+     * Append one bitstream created from number to another
+     * @param $bitstream (array) original bitstream
+     * @param $bits (int) number of bits
+     * @param $num (int) number
+     * @return array bitstream
+     */
+    protected function appendNum($bitstream, $bits, $num) {
+        if ($bits == 0) {
+            return 0;
+        }
+        $b = $this->newFromNum($bits, $num);
+        return $this->appendBitstream($bitstream, $b);
+    }
+
+    /**
+     * Append one bitstream created from bytes to another
+     * @param $bitstream (array) original bitstream
+     * @param $size (int) size
+     * @param $data (array) bytes
+     * @return array bitstream
+     */
+    protected function appendBytes($bitstream, $size, $data) {
+        if ($size == 0) {
+            return 0;
+        }
+        $b = $this->newFromBytes($size, $data);
+        return $this->appendBitstream($bitstream, $b);
+    }
+
+    /**
+     * Convert bitstream to bytes
+     * @param $bstream (array) original bitstream
+     * @return array of bytes
+     */
+    protected function bitstreamToByte($bstream) {
+        if (is_null($bstream)) {
+            return null;
+        }
+        $size = count($bstream);
+        if ($size == 0) {
+            return array();
+        }
+        $data = array_fill(0, (int) (($size + 7) / 8), 0);
+        $bytes = (int) ($size / 8);
+        $p = 0;
+        for ($i = 0; $i < $bytes; $i++) {
+            $v = 0;
+            for ($j = 0; $j < 8; $j++) {
+                $v = $v << 1;
+                $v |= $bstream[$p];
+                $p++;
+            }
+            $data[$i] = $v;
+        }
+        if ($size & 7) {
+            $v = 0;
+            for ($j = 0; $j < ($size & 7); $j++) {
+                $v = $v << 1;
+                $v |= $bstream[$p];
+                $p++;
+            }
+            $data[$bytes] = $v;
+        }
+        return $data;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRspec
+
+    /**
+     * Replace a value on the array at the specified position
+     * @param $srctab (array)
+     * @param $x (int) X position
+     * @param $y (int) Y position
+     * @param $repl (string) value to replace
+     * @param $replLen (int) length of the repl string
+     * @return array srctab
+     */
+    protected function qrstrset($srctab, $x, $y, $repl, $replLen = false) {
+        $srctab[$y] = substr_replace($srctab[$y], ($replLen !== false) ? substr($repl, 0, $replLen) : $repl, $x, ($replLen !== false) ? $replLen : strlen($repl));
+        return $srctab;
+    }
+
+    /**
+     * Return maximum data code length (bytes) for the version.
+     * @param $version (int) version
+     * @param $level (int) error correction level
+     * @return int maximum size (bytes)
+     */
+    protected function getDataLength($version, $level) {
+        return $this->capacity[$version][QRCAP_WORDS] - $this->capacity[$version][QRCAP_EC][$level];
+    }
+
+    /**
+     * Return maximum error correction code length (bytes) for the version.
+     * @param $version (int) version
+     * @param $level (int) error correction level
+     * @return int ECC size (bytes)
+     */
+    protected function getECCLength($version, $level) {
+        return $this->capacity[$version][QRCAP_EC][$level];
+    }
+
+    /**
+     * Return the width of the symbol for the version.
+     * @param $version (int) version
+     * @return int width
+     */
+    protected function getWidth($version) {
+        return $this->capacity[$version][QRCAP_WIDTH];
+    }
+
+    /**
+     * Return the numer of remainder bits.
+     * @param $version (int) version
+     * @return int number of remainder bits
+     */
+    protected function getRemainder($version) {
+        return $this->capacity[$version][QRCAP_REMINDER];
+    }
+
+    /**
+     * Return a version number that satisfies the input code length.
+     * @param $size (int) input code length (byte)
+     * @param $level (int) error correction level
+     * @return int version number
+     */
+    protected function getMinimumVersion($size, $level) {
+        for ($i = 1; $i <= QRSPEC_VERSION_MAX; ++$i) {
+            $words = $this->capacity[$i][QRCAP_WORDS] - $this->capacity[$i][QRCAP_EC][$level];
+            if ($words >= $size) {
+                return $i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Return the size of length indicator for the mode and version.
+     * @param $mode (int) encoding mode
+     * @param $version (int) version
+     * @return int the size of the appropriate length indicator (bits).
+     */
+    protected function lengthIndicator($mode, $version) {
+        if ($mode == QR_MODE_ST) {
+            return 0;
+        }
+        if ($version <= 9) {
+            $l = 0;
+        } elseif ($version <= 26) {
+            $l = 1;
+        } else {
+            $l = 2;
+        }
+        return $this->lengthTableBits[$mode][$l];
+    }
+
+    /**
+     * Return the maximum length for the mode and version.
+     * @param $mode (int) encoding mode
+     * @param $version (int) version
+     * @return int the maximum length (bytes)
+     */
+    protected function maximumWords($mode, $version) {
+        if ($mode == QR_MODE_ST) {
+            return 3;
+        }
+        if ($version <= 9) {
+            $l = 0;
+        } else if ($version <= 26) {
+            $l = 1;
+        } else {
+            $l = 2;
+        }
+        $bits = $this->lengthTableBits[$mode][$l];
+        $words = (1 << $bits) - 1;
+        if ($mode == QR_MODE_KJ) {
+            $words *= 2; // the number of bytes is required
+        }
+        return $words;
+    }
+
+    /**
+     * Return an array of ECC specification.
+     * @param $version (int) version
+     * @param $level (int) error correction level
+     * @param $spec (array) an array of ECC specification contains as following: {# of type1 blocks, # of data code, # of ecc code, # of type2 blocks, # of data code}
+     * @return array spec
+     */
+    protected function getEccSpec($version, $level, $spec) {
+        if (count($spec) < 5) {
+            $spec = array(0, 0, 0, 0, 0);
+        }
+        $b1 = $this->eccTable[$version][$level][0];
+        $b2 = $this->eccTable[$version][$level][1];
+        $data = $this->getDataLength($version, $level);
+        $ecc = $this->getECCLength($version, $level);
+        if ($b2 == 0) {
+            $spec[0] = $b1;
+            $spec[1] = (int) ($data / $b1);
+            $spec[2] = (int) ($ecc / $b1);
+            $spec[3] = 0;
+            $spec[4] = 0;
+        } else {
+            $spec[0] = $b1;
+            $spec[1] = (int) ($data / ($b1 + $b2));
+            $spec[2] = (int) ($ecc / ($b1 + $b2));
+            $spec[3] = $b2;
+            $spec[4] = $spec[1] + 1;
+        }
+        return $spec;
+    }
+
+    /**
+     * Put an alignment marker.
+     * @param $frame (array) frame
+     * @param $ox (int) X center coordinate of the pattern
+     * @param $oy (int) Y center coordinate of the pattern
+     * @return array frame
+     */
+    protected function putAlignmentMarker($frame, $ox, $oy) {
+        $finder = array(
+            "\xa1\xa1\xa1\xa1\xa1",
+            "\xa1\xa0\xa0\xa0\xa1",
+            "\xa1\xa0\xa1\xa0\xa1",
+            "\xa1\xa0\xa0\xa0\xa1",
+            "\xa1\xa1\xa1\xa1\xa1"
+        );
+        $yStart = $oy - 2;
+        $xStart = $ox - 2;
+        for ($y = 0; $y < 5; $y++) {
+            $frame = $this->qrstrset($frame, $xStart, $yStart + $y, $finder[$y]);
+        }
+        return $frame;
+    }
+
+    /**
+     * Put an alignment pattern.
+     * @param $version (int) version
+     * @param $frame (array) frame
+     * @param $width (int) width
+     * @return array frame
+     */
+    protected function putAlignmentPattern($version, $frame, $width) {
+        if ($version < 2) {
+            return $frame;
+        }
+        $d = $this->alignmentPattern[$version][1] - $this->alignmentPattern[$version][0];
+        if ($d < 0) {
+            $w = 2;
+        } else {
+            $w = (int) (($width - $this->alignmentPattern[$version][0]) / $d + 2);
+        }
+        if ($w * $w - 3 == 1) {
+            $x = $this->alignmentPattern[$version][0];
+            $y = $this->alignmentPattern[$version][0];
+            $frame = $this->putAlignmentMarker($frame, $x, $y);
+            return $frame;
+        }
+        $cx = $this->alignmentPattern[$version][0];
+        $wo = $w - 1;
+        for ($x = 1; $x < $wo; ++$x) {
+            $frame = $this->putAlignmentMarker($frame, 6, $cx);
+            $frame = $this->putAlignmentMarker($frame, $cx, 6);
+            $cx += $d;
+        }
+        $cy = $this->alignmentPattern[$version][0];
+        for ($y = 0; $y < $wo; ++$y) {
+            $cx = $this->alignmentPattern[$version][0];
+            for ($x = 0; $x < $wo; ++$x) {
+                $frame = $this->putAlignmentMarker($frame, $cx, $cy);
+                $cx += $d;
+            }
+            $cy += $d;
+        }
+        return $frame;
+    }
+
+    /**
+     * Return BCH encoded version information pattern that is used for the symbol of version 7 or greater. Use lower 18 bits.
+     * @param $version (int) version
+     * @return BCH encoded version information pattern
+     */
+    protected function getVersionPattern($version) {
+        if (($version < 7) OR ($version > QRSPEC_VERSION_MAX)) {
+            return 0;
+        }
+        return $this->versionPattern[($version - 7)];
+    }
+
+    /**
+     * Return BCH encoded format information pattern.
+     * @param $mask (array)
+     * @param $level (int) error correction level
+     * @return BCH encoded format information pattern
+     */
+    protected function getFormatInfo($mask, $level) {
+        if (($mask < 0) OR ($mask > 7)) {
+            return 0;
+        }
+        if (($level < 0) OR ($level > 3)) {
+            return 0;
+        }
+        return $this->formatInfo[$level][$mask];
+    }
+
+    /**
+     * Put a finder pattern.
+     * @param $frame (array) frame
+     * @param $ox (int) X center coordinate of the pattern
+     * @param $oy (int) Y center coordinate of the pattern
+     * @return array frame
+     */
+    protected function putFinderPattern($frame, $ox, $oy) {
+        $finder = array(
+            "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
+            "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
+            "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+            "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+            "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+            "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
+            "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
+        );
+        for ($y = 0; $y < 7; $y++) {
+            $frame = $this->qrstrset($frame, $ox, ($oy + $y), $finder[$y]);
+        }
+        return $frame;
+    }
+
+    /**
+     * Return a copy of initialized frame.
+     * @param $version (int) version
+     * @return Array of unsigned char.
+     */
+    protected function createFrame($version) {
+        $width = $this->capacity[$version][QRCAP_WIDTH];
+        $frameLine = str_repeat("\0", $width);
+        $frame = array_fill(0, $width, $frameLine);
+        // Finder pattern
+        $frame = $this->putFinderPattern($frame, 0, 0);
+        $frame = $this->putFinderPattern($frame, $width - 7, 0);
+        $frame = $this->putFinderPattern($frame, 0, $width - 7);
+        // Separator
+        $yOffset = $width - 7;
+        for ($y = 0; $y < 7; ++$y) {
+            $frame[$y][7] = "\xc0";
+            $frame[$y][$width - 8] = "\xc0";
+            $frame[$yOffset][7] = "\xc0";
+            ++$yOffset;
+        }
+        $setPattern = str_repeat("\xc0", 8);
+        $frame = $this->qrstrset($frame, 0, 7, $setPattern);
+        $frame = $this->qrstrset($frame, $width - 8, 7, $setPattern);
+        $frame = $this->qrstrset($frame, 0, $width - 8, $setPattern);
+        // Format info
+        $setPattern = str_repeat("\x84", 9);
+        $frame = $this->qrstrset($frame, 0, 8, $setPattern);
+        $frame = $this->qrstrset($frame, $width - 8, 8, $setPattern, 8);
+        $yOffset = $width - 8;
+        for ($y = 0; $y < 8; ++$y, ++$yOffset) {
+            $frame[$y][8] = "\x84";
+            $frame[$yOffset][8] = "\x84";
+        }
+        // Timing pattern
+        $wo = $width - 15;
+        for ($i = 1; $i < $wo; ++$i) {
+            $frame[6][7 + $i] = chr(0x90 | ($i & 1));
+            $frame[7 + $i][6] = chr(0x90 | ($i & 1));
+        }
+        // Alignment pattern
+        $frame = $this->putAlignmentPattern($version, $frame, $width);
+        // Version information
+        if ($version >= 7) {
+            $vinf = $this->getVersionPattern($version);
+            $v = $vinf;
+            for ($x = 0; $x < 6; ++$x) {
+                for ($y = 0; $y < 3; ++$y) {
+                    $frame[($width - 11) + $y][$x] = chr(0x88 | ($v & 1));
+                    $v = $v >> 1;
+                }
+            }
+            $v = $vinf;
+            for ($y = 0; $y < 6; ++$y) {
+                for ($x = 0; $x < 3; ++$x) {
+                    $frame[$y][$x + ($width - 11)] = chr(0x88 | ($v & 1));
+                    $v = $v >> 1;
+                }
+            }
+        }
+        // and a little bit...
+        $frame[$width - 8][8] = "\x81";
+        return $frame;
+    }
+
+    /**
+     * Set new frame for the specified version.
+     * @param $version (int) version
+     * @return Array of unsigned char.
+     */
+    protected function newFrame($version) {
+        if (($version < 1) OR ($version > QRSPEC_VERSION_MAX)) {
+            return NULL;
+        }
+        if (!isset($this->frames[$version])) {
+            $this->frames[$version] = $this->createFrame($version);
+        }
+        if (is_null($this->frames[$version])) {
+            return NULL;
+        }
+        return $this->frames[$version];
+    }
+
+    /**
+     * Return block number 0
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsBlockNum($spec) {
+        return ($spec[0] + $spec[3]);
+    }
+
+    /**
+     * Return block number 1
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsBlockNum1($spec) {
+        return $spec[0];
+    }
+
+    /**
+     * Return data codes 1
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsDataCodes1($spec) {
+        return $spec[1];
+    }
+
+    /**
+     * Return ecc codes 1
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsEccCodes1($spec) {
+        return $spec[2];
+    }
+
+    /**
+     * Return block number 2
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsBlockNum2($spec) {
+        return $spec[3];
+    }
+
+    /**
+     * Return data codes 2
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsDataCodes2($spec) {
+        return $spec[4];
+    }
+
+    /**
+     * Return ecc codes 2
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsEccCodes2($spec) {
+        return $spec[2];
+    }
+
+    /**
+     * Return data length
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsDataLength($spec) {
+        return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]);
+    }
+
+    /**
+     * Return ecc length
+     * @param $spec (array)
+     * @return int value
+     */
+    protected function rsEccLength($spec) {
+        return ($spec[0] + $spec[3]) * $spec[2];
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRrs
+
+    /**
+     * Initialize a Reed-Solomon codec and add it to existing rsitems
+     * @param $symsize (int) symbol size, bits
+     * @param $gfpoly (int)  Field generator polynomial coefficients
+     * @param $fcr (int)  first root of RS code generator polynomial, index form
+     * @param $prim (int)  primitive element to generate polynomial roots
+     * @param $nroots (int) RS code generator polynomial degree (number of roots)
+     * @param $pad (int)  padding bytes at front of shortened block
+     * @return array Array of RS values:<ul><li>mm = Bits per symbol;</li><li>nn = Symbols per block;</li><li>alpha_to = log lookup table array;</li><li>index_of = Antilog lookup table array;</li><li>genpoly = Generator polynomial array;</li><li>nroots = Number of generator;</li><li>roots = number of parity symbols;</li><li>fcr = First consecutive root, index form;</li><li>prim = Primitive element, index form;</li><li>iprim = prim-th root of 1, index form;</li><li>pad = Padding bytes in shortened block;</li><li>gfpoly</ul>.
+     */
+    protected function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad) {
+        foreach ($this->rsitems as $rs) {
+            if (($rs['pad'] != $pad) OR ($rs['nroots'] != $nroots) OR ($rs['mm'] != $symsize)
+                    OR ($rs['gfpoly'] != $gfpoly) OR ($rs['fcr'] != $fcr) OR ($rs['prim'] != $prim)) {
+                continue;
+            }
+            return $rs;
+        }
+        $rs = $this->init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
+        array_unshift($this->rsitems, $rs);
+        return $rs;
+    }
+
+    // - - - - - - - - - - - - - - - - - - - - - - - - -
+    // QRrsItem
+
+    /**
+     * modnn
+     * @param $rs (array) RS values
+     * @param $x (int) X position
+     * @return int X osition
+     */
+    protected function modnn($rs, $x) {
+        while ($x >= $rs['nn']) {
+            $x -= $rs['nn'];
+            $x = ($x >> $rs['mm']) + ($x & $rs['nn']);
+        }
+        return $x;
+    }
+
+    /**
+     * Initialize a Reed-Solomon codec and returns an array of values.
+     * @param $symsize (int) symbol size, bits
+     * @param $gfpoly (int)  Field generator polynomial coefficients
+     * @param $fcr (int)  first root of RS code generator polynomial, index form
+     * @param $prim (int)  primitive element to generate polynomial roots
+     * @param $nroots (int) RS code generator polynomial degree (number of roots)
+     * @param $pad (int)  padding bytes at front of shortened block
+     * @return array Array of RS values:<ul><li>mm = Bits per symbol;</li><li>nn = Symbols per block;</li><li>alpha_to = log lookup table array;</li><li>index_of = Antilog lookup table array;</li><li>genpoly = Generator polynomial array;</li><li>nroots = Number of generator;</li><li>roots = number of parity symbols;</li><li>fcr = First consecutive root, index form;</li><li>prim = Primitive element, index form;</li><li>iprim = prim-th root of 1, index form;</li><li>pad = Padding bytes in shortened block;</li><li>gfpoly</ul>.
+     */
+    protected function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad) {
+        // Based on Reed solomon encoder by Phil Karn, KA9Q (GNU-LGPLv2)
+        $rs = null;
+        // Check parameter ranges
+        if (($symsize < 0) OR ($symsize > 8)) {
+            return $rs;
+        }
+        if (($fcr < 0) OR ($fcr >= (1 << $symsize))) {
+            return $rs;
+        }
+        if (($prim <= 0) OR ($prim >= (1 << $symsize))) {
+            return $rs;
+        }
+        if (($nroots < 0) OR ($nroots >= (1 << $symsize))) {
+            return $rs;
+        }
+        if (($pad < 0) OR ($pad >= ((1 << $symsize) - 1 - $nroots))) {
+            return $rs;
+        }
+        $rs = array();
+        $rs['mm'] = $symsize;
+        $rs['nn'] = (1 << $symsize) - 1;
+        $rs['pad'] = $pad;
+        $rs['alpha_to'] = array_fill(0, ($rs['nn'] + 1), 0);
+        $rs['index_of'] = array_fill(0, ($rs['nn'] + 1), 0);
+        // PHP style macro replacement ;)
+        $NN = & $rs['nn'];
+        $A0 = & $NN;
+        // Generate Galois field lookup tables
+        $rs['index_of'][0] = $A0; // log(zero) = -inf
+        $rs['alpha_to'][$A0] = 0; // alpha**-inf = 0
+        $sr = 1;
+        for ($i = 0; $i < $rs['nn']; ++$i) {
+            $rs['index_of'][$sr] = $i;
+            $rs['alpha_to'][$i] = $sr;
+            $sr <<= 1;
+            if ($sr & (1 << $symsize)) {
+                $sr ^= $gfpoly;
+            }
+            $sr &= $rs['nn'];
+        }
+        if ($sr != 1) {
+            // field generator polynomial is not primitive!
+            return NULL;
+        }
+        // Form RS code generator polynomial from its roots
+        $rs['genpoly'] = array_fill(0, ($nroots + 1), 0);
+        $rs['fcr'] = $fcr;
+        $rs['prim'] = $prim;
+        $rs['nroots'] = $nroots;
+        $rs['gfpoly'] = $gfpoly;
+        // Find prim-th root of 1, used in decoding
+        for ($iprim = 1; ($iprim % $prim) != 0; $iprim += $rs['nn']) {
+            ; // intentional empty-body loop!
+        }
+        $rs['iprim'] = (int) ($iprim / $prim);
+        $rs['genpoly'][0] = 1;
+        for ($i = 0, $root = $fcr * $prim; $i < $nroots; $i++, $root += $prim) {
+            $rs['genpoly'][$i + 1] = 1;
+            // Multiply rs->genpoly[] by  @**(root + x)
+            for ($j = $i; $j > 0; --$j) {
+                if ($rs['genpoly'][$j] != 0) {
+                    $rs['genpoly'][$j] = $rs['genpoly'][$j - 1] ^ $rs['alpha_to'][$this->modnn($rs, $rs['index_of'][$rs['genpoly'][$j]] + $root)];
+                } else {
+                    $rs['genpoly'][$j] = $rs['genpoly'][$j - 1];
+                }
+            }
+            // rs->genpoly[0] can never be zero
+            $rs['genpoly'][0] = $rs['alpha_to'][$this->modnn($rs, $rs['index_of'][$rs['genpoly'][0]] + $root)];
+        }
+        // convert rs->genpoly[] to index form for quicker encoding
+        for ($i = 0; $i <= $nroots; ++$i) {
+            $rs['genpoly'][$i] = $rs['index_of'][$rs['genpoly'][$i]];
+        }
+        return $rs;
+    }
+
+    /**
+     * Encode a Reed-Solomon codec and returns the parity array
+     * @param $rs (array) RS values
+     * @param $data (array) data
+     * @param $parity (array) parity
+     * @return parity array
+     */
+    protected function encode_rs_char($rs, $data, $parity) {
+        $MM = & $rs['mm']; // bits per symbol
+        $NN = & $rs['nn']; // the total number of symbols in a RS block
+        $ALPHA_TO = & $rs['alpha_to']; // the address of an array of NN elements to convert Galois field elements in index (log) form to polynomial form
+        $INDEX_OF = & $rs['index_of']; // the address of an array of NN elements to convert Galois field elements in polynomial form to index (log) form
+        $GENPOLY = & $rs['genpoly']; // an array of NROOTS+1 elements containing the generator polynomial in index form
+        $NROOTS = & $rs['nroots']; // the number of roots in the RS code generator polynomial, which is the same as the number of parity symbols in a block
+        $FCR = & $rs['fcr']; // first consecutive root, index form
+        $PRIM = & $rs['prim']; // primitive element, index form
+        $IPRIM = & $rs['iprim']; // prim-th root of 1, index form
+        $PAD = & $rs['pad']; // the number of pad symbols in a block
+        $A0 = & $NN;
+        $parity = array_fill(0, $NROOTS, 0);
+        for ($i = 0; $i < ($NN - $NROOTS - $PAD); $i++) {
+            $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
+            if ($feedback != $A0) {
+                // feedback term is non-zero
+                // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
+                // always be for the polynomials constructed by init_rs()
+                $feedback = $this->modnn($rs, $NN - $GENPOLY[$NROOTS] + $feedback);
+                for ($j = 1; $j < $NROOTS; ++$j) {
+                    $parity[$j] ^= $ALPHA_TO[$this->modnn($rs, $feedback + $GENPOLY[($NROOTS - $j)])];
+                }
+            }
+            // Shift
+            array_shift($parity);
+            if ($feedback != $A0) {
+                array_push($parity, $ALPHA_TO[$this->modnn($rs, $feedback + $GENPOLY[0])]);
+            } else {
+                array_push($parity, 0);
+            }
+        }
+        return $parity;
+    }
+
+}
+
+// end QRcode class
+
+//============================================================+
+// END OF FILE
+//============================================================+

vendor/milon/barcode/src/config/config.php

+<?php
+
+return [
+    'store_path' => public_path("/"),
+];

vendor/milon/barcode/src/routes.php

+<?php
+
+/*
+  |--------------------------------------------------------------------------
+  | Milon/Barcode Routes
+  |--------------------------------------------------------------------------
+  |
+  | Here is where you can register all of the routes for an application.
+  | It's a breeze. Simply tell Laravel the URIs it should respond to
+  | and give it the Closure to execute when that URI is requested.
+  |
+ */
+
+
+Route::get('/barcodes', function() {
+       return "barcodes";
+});
\ No newline at end of file